madelyn

This is really interesting. Are there restrictions or limitations on the PageServer + Safekeeper design when running OLAP queries on larger datasets?

Phrased another way, would a query that needs to access a relatively large amount of data (10-100 GB) ever need to read from s3, incurring extra latency?

In a house of two women with long hair, I highly doubt my GPU could survive me and my girlfriend over two weeks.

Looks absolutely sleek, but if it had a base and a glass and aluminum cloche-style cover it'd be more practical. Open air just seems like a disaster waiting to happen.

I've played NMS pretty much since release, off and on. First on Playstation, but I then bought it on Steam for Linux and plan to get it on the Switch when it drops.

It's a fantastic game if you have friends to play with, or are interested in joining online groups. There's thousands of planets out there and I still get excited when I'm in a random galaxy and find something awesome I can share with the community.

The single player in NMS is less fun than Multiplayer, but if you are down for what is basically space minecraft I still would say it's worth it!

And for anyone wondering, it works great on Proton and the devs are maintaining support for Proton as well (thanks, Steam Deck!)

Wow!!! This is awesome, I've wanted something like the mix tool for quite some time.

Thank you!

I mean, yes, if you know Ruby. If you as a founder know Python, just use Django. They're sister frameworks.

I mean, considering how much code, especially scripting and pipeline work, is required to produce most modern movies, these days most movies are programming projects in one way or another.

100% this. A "knee pillow" has been life changing for me.

I picked up the practice originally after long hikes. It's amazing how much it helps with the soreness.

I just take a regular, commodity pillow and fold it in half. Any kind you can get at your local store works great!

React can work really nicely with different parts of the DOM via Portals however!!

Portals are awesome for use cases where you're sprinkling dynamic bits into an SSR'd shell. And for all parts of your app that don't need that level of interactivity, you've got plain old templates in your server side language of choice.

There's some limits to this but it's a neat trick.

You can use SQLAlchemy like Ecto or in a functional manner, especially with core.

But a lot of projects I've seen around the web try to bend the sqlalchemy ORM into a more "active record" way of working.

Hey, this looks awesome! Definitely echoing the abuse potential concerns shared by other commentators.

You might want to consider hosting content published on a different domain from your main site, otherwise search engines and site lists could flag the domain as a bad actor if something gets through.

Hi Ali! I'm a software engineering lead working in the Shopify ecosystem as well.

This is an awesome resource, I just shared it around at my company. It's a lot of data to crawl and no joke!

Thank you so much!

Hey, this product looks like a pretty decent "stack agnostic" way to handle auth. I've definitely considered using services like Cognito but always returned to "DIY" for the data ownership. A couple questions:

1. How will you keep bigger engineering teams on your platform if access to the data (and therefore migration) is easy?

2. I mainly work with Python. Typically I use Django's user system with my own user model and I copy and paste the client company's "general email template" into the verification / signup / reset emails and I'm done with it. If I need it on multiple services I install a JWT plugin. It takes maybe 10 minutes at the start of a project, and the developer experience is similar from what I have heard in Rails with Devise. Does this service have anything to offer to these "mature" stacks, or are you generally targeting newer ecosystems like Node / "frontend first" projects?

Also, your landing page looks great!! :)

I wrote a little library that does exactly this, though it's framework agnostic. I agree being able to use components in Python for webdev is nice.

It's called "dashml" on PyPi if anyone is interested. I mostly use it in Django and haven't worked on it lately cause of $DAYJOB though.

Give aldjemy a try! You can construct sqlalchemy queries/sql in general from your Django models. It's amazing and magical for complex queries!

You can definitely implement a lot of functional concepts in Python though.

I write Python in a really functional style, and sure I had to define things like `compose` in a module but it works ok.

I find that once code starts getting higher level, you need lambdas less. Ex. You have functions or objects that generate common callbacks you can plug wherever you want.

There's also great functional libraries. Funcparserlib is amazing, and you can wrap sqlalchemy core in a functional way.

Plus there is always Hylang which works perfectly with existing Python code.

You don't have type safety but there's not much stopping you from having a good time with it! At least, in my experience. It's not Haskell though, and never will be.

This might be cynical but maybe because most individual pieces of software don't matter too much.

Software is much easier to change than other things that humans build. It's easier to replace, sometimes with success, than what other disciplines have to work with. A lot of software isn't used in safety critical areas either so failing is acceptable. Lots of companies on the web have lots of downtime and still make money.

Even poorly written software can absolutely print money with huge margins. And old software that's still around and kicking is often the most successful!! A form of survivorship bias.

Sure, _products_ often matter a lot. But within them and as long as they still solve their problems, it doesn't really matter what's inside. If a product I use as an end user has a lot of internal churn, but still solves my problem adequately, I don't really care for the most part.

Sure, if it's medical software, or aviation software, or software to replace an elevator panel, I might care a lot. But your average web app or desktop program?

For me it was just structure and ease of use. You can configure vim to make files on specific keypresses to link your diy wiki together, use gf like you mentioned to jump around, make your own auto folding and stuff...

Or you can be lazy and install a plugin that takes thirty seconds to get the hang of.

Actually writing and staying organized has been challenging due to the fact I don't focus well. Spending time recreating vimwiki is time not spent staying organized. Vimwiki has low friction so I use it.

I mean, possibly? What's considered the gold standard in package management these days?

I use yarn for managing javascript dependencies and do a lot of work with Cargo too. The community seems to love both these tools outside of slow compile and install times.

People always get up in arms about this, but as someone who has used Python as her daily driver for years it's really... never been this serious of an issue for me?

I have used virtualenv/venv and pip to install dependencies for years and years, since I was a teen hacking around with Python. Packaging files with setup.py doesn't really seem that hard. I've published a few packages on pypi for my own personal use and it's not been too frustrating.

A lot of the issues people have with Python packaging seem like they can get replaced with a couple shell aliases. Dependency hell with too many dependencies becomes unruly in any package manager I've tried.

Is the "silent majority" just productive with the status quo and getting work done with Python behind the scenes? Why is my experience apparently so atypical?

Vine reviews are disclosed in the app or on the website, though. I don't really see that as malicious.

For anyone interested in Starlette or general async programming in Python, I also want to point out that there's a few great packages maintained by Encode/Tom Christie (of Django Rest Framework fame).

The developer ergonomics are getting really good, I especially love encode/databases, which has full support for SQLAlchemy Core, and encode/httpx, a requests-like HTTP client.

https://github.com/encode

I have never understood the need for all the different tools surrounding Python packaging, development environments, or things like Pipenv. For years, I have used Virtualenv and a script to create a virtual environment in my project folder. It's as simple as a node_modules folder, the confusion around it is puzzling to me.

Nowadays, using setuptools to create packages is really easy too, there's a great tutorial on the main Python site. It's not as easy as node.js, sure, but there's tools like Cookiecutter to remove the boilerplate from new packages.

requirements.txt files aren't very elegant, but they work well enough.

And with docker, all this is is even easier. The python + docker story is really nice.

Honestly I just love these basic tools and how they let me do my job without worrying about are they the latest and greatest. My python setup has been stable for years and I am so productive with it.

Exactly, CQRS gets such a bad rep because of all the pieces that (typically) surround it. But really as just a way of organizing code, it's so handy.

The freedom and flexibility to create your read models and write models the way they are needed just completely sidesteps a lot of design issues that creep up. Plus, it makes the code so easy to follow when everything follows the pattern; picking out where state changes happen becomes trivial for example.

Graphviz is pretty great for creating diagrams, though if you have specific style needs it can require a good deal of boilerplate.

This reminds me how for awhile I was emailing myself .tar and .exe files through Gmail or school email systems by renaming them to .jpeg files.

Recent-ish (past year) Gmail patched this (for .tar at least), so I started using base64 encoded text files.

Now though I just pay for my own email service away from Google.

If it's just "hello world" in this day and age of good frameworks, great open source tooling like Terraform and SaaS offerings that's not too tall of an order.

Can you elaborate a bit on this please? I'd be interested in resources on writing better parsers!

Quickly looking at the python standard lib (urlparse, shlex, etc) and Python packages (NLTK Treebank tokenizer), a lot of packages related to slicing, dicing and parsing strings use a mashup of regex and rule based code.