gtoolkit VS CPython

You might find Glamorous Toolkit[1] and Folk computer[2] in that category too! Full disclaimer, I currently contribute to Folk (it's still pre-alpha but it has some really exciting ideas).

[1] https://gtoolkit.com/

[2] https://folk.computer/

> we should be able to do better than text files

https://gtoolkit.com/

?

Are you using Pharo already? If not, give it a go: https://pharo.org/

For taking notes and stuff you'd otherwise do in Jupyter or Livebook, try GT: https://gtoolkit.com/

It's not an OS, but you can just abstract over OS actions within either and keep them as your main interface, similar to how some people rarely leave Emacs.

Having GUI tooling to inspect, debug and develop integrated in the execution environment is kind of Smalltalk's thing. It's like a Common Lisp with more clicking in that regard.

It's rather neat, and means you can extend your development environment in the same way you develop your applications. If you want to extend the inspector for a particular type of object you can do that. Compared to writing plugins for Eclipse or IntelliJ it's a trivial exercise.

GT does it too, though explicitly aimed at tool development rather than application development: https://gtoolkit.com/

In a sense it's the original vibe coding environment.

Nice set of features you have here, very similar to Smalltalk (particularly Pharo) ideals. Actually I'm also actively working on a Pharo VM simulator so I can ultimately get GToolkit[0], which I really like and is based on it, running in Python. Nothing published yet though, but can definitely get in touch via your project.

[0] https://gtoolkit.com/

Cool, reminds me somewhat of Glamorous Toolkit [1], another project I just found out about. Excited to give it a try, I love these sort of "explain a program as it's running" type tools.

1. https://gtoolkit.com/

https://book.gtoolkit.com/understanding-lepiter-in-7--6n7q1o...

> I know to really use it, I have to learn to program it, but I am also of the mind basic functionality should be self explanatory. And pharo itself as the basis of this seems so convoluted and complex...

We use Pharo as a programming language for building the system, and most extensions are expected to be written in it. It's possible to connect to other runtimes, like Python or JS, and extend the object inspector that works with remote objects using those languages. But overall, learning Pharo is a bit of a prerequisite. I certainly understand that it can appear foreign, but convoluted and complex are not an attributes I would associate with it :).

Now, in GT, the environment is built from the ground up anew and it's different from classic interfaces found in Pharo or Cuis. And of course, it's different from typical development environment, too, because we wanted to build a different kind of interface in which visualization is a first class entity.

Our community is indeed on Discord a lot, but we also host discussions on our GitHub repository: https://github.com/feenkcom/gtoolkit/discussions

In any case, I am happy you find the need for "a great knowledge base and data visualization" relevant and useful.

This might be what you're looking for... https://gtoolkit.com/

> with very little way to find and eliminate them.

The best Smalltalk these days is GlamorousToolkit: https://gtoolkit.com/

It has a sort of git in it, so you can easily "rollback" your image to previous states. So going back and forth in history is trivial.

Here's the relevant diff: https://github.com/python/cpython/pull/137968/files#diff-966...

Search is limited to 20 attributes and non-descriptors only to avoid arbitrary code execution.

I assume constructing AttributeErrors isn't highly performance sensitive.

If there is an audience for release notes I haven't seen anything better than just committing entries to pre-release folder as you change things and have release automation compile the folder into the actual release notes. Python and many other large projects handle it like this: https://github.com/python/cpython/tree/main/Misc/NEWS.d/next (The release notes for major releases are crafted manually)

Python Software Foundation. Python Programming Language. https://www.python.org/

import smtplib from email.mime.text import MIMEText from email.mime.multipart import MIMEMultipart from email.mime.base import MIMEBase from email import encoders # SMTP Server details port = 587 smtp_server = "smtp.sendlayer.net" username = "paulie" # Your username generated by SendLayer password = "sendlayer_smtp_password" # Your password generated by SendLayer sender_email = "paulie@example.com" receiver_email = "johndoe@example.com" # Email content subject = "Email Example with Attachment" html_message = """\ Hi, This is a test email sent from "https://www.python.org">Python using "https://sendlayer.com">SendLayer's SMTP server The email also includes an attachment """ # Create a multipart message and set headers message = MIMEMultipart() message["From"] = sender_email message["Subject"] = subject message["To"] = receiver_email # Attach the HTML part message.attach(MIMEText(html_message, "html")) # Specify the file path for the attachment filename = "./path/to/attachment/file.pdf" # Change this to the correct path # Open the file in binary mode with open(filename, "rb") as attachment: part = MIMEBase("application", "octet-stream") part.set_payload(attachment.read()) # Encode file in ASCII characters to send by email encoders.encode_base64(part) # Add header as key/value pair to attachment part part.add_header("Content-Disposition", f"attachment; filename= {filename}") # Add attachment to message message.attach(part) # Send the email with smtplib.SMTP(smtp_server, port) as server: server.starttls() server.login(username, password) server.sendmail(sender_email, receiver_email, message.as_string()) print('Email sent successfully')

import requests from concurrent.futures import ThreadPoolExecutor URLS = [ "https://www.python.org/", "https://www.djangoproject.com/", "https://flask.palletsprojects.com/", ] def fetch_url(url: str): print(f"Fetching {url}...") response = requests.get(url) print(f"Fetched {url} with status {response.status_code}") return len(response.content) with ThreadPoolExecutor(max_workers=5) as executor: # The map function runs `fetch_url` for each item in URLS results = executor.map(fetch_url, URLS) for url, length in zip(URLS, results): print(f"URL: {url}, Length: {length}")

Use KeysView and ValuesView instead of dict_keys and dict_values respectively because type checkers don't support dict_keys and dict_values in _collections_abc.

According to the benchmark in the PR that introduced this optimization, sorting a list that consists only of floats rather than a list of floats with even a single integer at the end is almost twice as fast.

If you want to a UUIDv7 key for partitioning your table by date (e.g., one partition per day or month), you need to be able to compute the partition range via the minimal UUIDv7 for a given date.

There is some discussion whether or not to add helpers for this to Python‘s uuid7 module: https://github.com/python/cpython/issues/130843#issuecomment...

With respect to tagged pointers, there seems to be some recent movements on that front in CPython: https://github.com/python/cpython/issues/132509