paddy_m

Even better if people bought ebikes. It is galling that rich people get a $7500 credit to buy a $50-100k luxury bauble, while there are no incentives for ebikes.

Detroit diesel two strokes were entirely mechanical. As were cummins engines like b5.9 with a bosch p-pump. In fact all diesel engines have fuel injection, and they were all mechanical up to the 80s/90s.

When you get to relational models, the amount of UI you can quickly build around the django admin is staggering... if you stay in the guardrails.

CAD Software. There is CAD vs CAD esports. https://www.youtube.com/live/C1CqIcfDKbQ?t=1987s It seems dominated by solidworks but other programs (NX, Fusion 360...?) are allowed.

The bloomberg terminal UI.

Some emacs setups. (much more variability than VIM)

Some VIM setups.

The thing that all of these have in common is that they are designed for experts, not for every user. Also each one of those is a custom full platform app (or primarily text based) vs web app.

Thanks, I'm starting to understand. So Display Postscript was useful because it let you know that what you put on the screen as a programmer would be what's printed?

And it allowed for cool graphics effects like custom strokes and fills.

So that primarily matters for stuff you want to print. It wouldn't matter as much for assembling a UI.

How does windows handle this stuff?

The best functional specs for a UI have come from business people building their own in excel. At a minimum they will have some idea of layout and what information should be displayed on which screens.

This also lets them focus on the core information, not the styling. Building GUIs on the web, there are infinite ways to style every UI element and more attention goes to that then the actual interaction.

What made display postscript so great? I have only seen it mentioned in frothy marketing terms, not an in depth discussion of its approach, why it worked well, and how that compares to other alternatives.

Location: Boston

Remote: Yes

Willing to relocate: Yes

Technologies: talking to users, python, pandas/numpy, jupyter, js/ts

Résumé/CV: https://www.linkedin.com/in/paddymullen/

Email: paddy@paddymullen.com

In my next role, I want a broad mandate to make a meaningful impact within an organization by developing products that address genuine business challenges, with a preference for data related problems.

Recently I built the data table for Jupyter/Pandas/Polars that I have wanted for over a decade. The open source Buckaroo (https://github.com/paddymul/buckaroo) data table combines a performant table, summary statistics, and a low code UI to expedite common data analysis tasks.

which implementation of `std()` did you go with?

I was writing unit tests once against histograms. That code is super finnicky, and I couldn't get pandas and polars numbers to tie out. I wasn't super concerned with the exact output for my application, just that number of buckets was the same and they were roughly the same size. Just bumping to a new version of numpy would result in test breakages because of floating point rounding errors. I'm sure there are much more robust numerical testing things I could have done

I was just commenting that I had glossed over that in multiple readings about different typing systems. The parent of my original comment explained it nicely.

I know that dependent type is the term of art, and you should probably keep it. You could say something along the lines of

"ovld supports dependent types (an additionally specific name for a type that is based on its value, ie > 0)" the first time you use the term dependent types."

That makes sense for writing your own generic libraries. Do you frequently have to convert from pytorch to numpy? I would think that a for a given execution unit (pipeline step, single program, model running on a server) that the data will stay as the same type after some initial conversion.

What is the return type of an overloaded function? I don't see that in any of the examples.

I think it would make sense to have each function return either the exact same type, or a generic.

  @ovld(int) #all of these overloads should return an int
  len(a:list) -> int
  len(a:str) -> int

  #the effective type of len is
  len(a:Union[int, str]) -> int

and then a generic example

  T = TypeVar('T')
  @ovld(T)
  add(a:np.int8, b:np.int8) -> np.int8

  @ovld(T)
  add(a:np.int16, b:np.int16) -> np.int16

In the second example, I don't know how you would connect the input params to the generic T. If you put concrete types in, I see how ovld works.

Am I missing something?

Value based dispatch is a much better name for it then Dependent Types. I have seen the term dependent types and just glossed over it because I thought it was a more complex topic.

This looks really cool. I get multiple dispatch, multi methods, and CLOS method specialization confused in my head. I can understand what this does... But when do you use it.

Can people list some times when they actually used multimethods to solve a real problem? How did it work out? Would you do it again?

I hope some typechecker starts doing serious supported notebook integration. And integration for live coding, not just a batch script to statically check your notebook. Finding errors with typing before running a 1-60 minute cell is a huge win.

Sometimes you want a specific limited subset of the parent language, especially when you don't want to expose a huge possibility space to non technical users. Exposing only a limited subset can also be helpful to sandbox for security reasons.

Russia is importing shells from North Korea. Transformers are more complex than you give them credit for, and Russia has a very limited ability to manufacture anything, it would make a difference.

Crippling the Russian train system would be very much worth it. Russia would have to switch to limited diesel locomotives, and it would really hurt regular civilian logistics in those areas.

Trent and a lot of Ukranian war commentators have a habit of saying $X is catastrophic for the Russians (this is the worst on YouTube). Then those catastrophic things don't come to pass.

Related, I have seen one guy, over and over say "Why isn't Ukraine hitting Russian electric train transformer stations". I don't have a good answer, most of Russia's rail network is electric, transformers blow up easily, there are many of them, and they would be very slow to replace. Ukraine clearly has deep strike capabilities, and Russia cant defend every transformer. I don't think it's a humanitarian issue, or at this point even an issue with the US telling Ukraine they can't hit those targets.

Specifically "Hands On ML 3", or just generally a copy of some exercise set from a class?

Another fun note about Russian logistics, they aren't palletized or mechanized. Thought being that cranes don't look good in parades. The train side seems smart or at least interesting, the pallets incredibly dumb.

https://x.com/TrentTelenko/status/1507056013245128716

I made a Marimo WASM example that you can play with in your browser [1]

I need to make some updates to the polars functionality, I just completed some extensive refactorings of the Lowcode UI focussed on pandas, time to clean that up for polars too.

Also the python codegen for polars is non-idiomatic with multiple re-assignments to a dataframe, vs one big select block. I have some ideas for how to fix that, but they'll take time.

https://marimo.io/p/@paddy-mullen/notebook-sctuj8

Thank you.

The Buckaroo lowcode UI is capable of working with Polars, but I don't currently have any commands plumbed in. I will work on that.

I'm aware of Data Wrangler and they did nice work, but it's closed source and from what I can tell non-extensible. What features do you like in Data Wrangler, what do you wish it did differently?

re:version control

How stable are node and edge IDs and their ordering? Could you sort the JSON before saving so the output is more stable and diff-able?

Another thought is, how would you code up a flow like this in your preferred language if you were just writing code in that language (you didn't care about the visual editting). Call most of the same functions, but do it directly. Ok, think about that, then write a transformation from the NODE language to output source in your preferred language.

I have some sense that coding this type of control flow logic doesn't work well with text line based diffs because of the complexity of the problem, less the syntax.

Ahh, you didn't create Node-RED editor. That's an external project. I didn't understand this at first, and probably explains a lot of my confusion

https://nodered.org/

This is related to visual programming, not flow based programming.

I modified a python hosted lisp interpreter to read JSON flavored lisp - JLISP. It's much easier to get a web frontend to output JSON then lisp. Then I made a simple Low Code UI built around this language. The editor has operations (invocations of lisp functions) organized left to right like a timeline in CAD software, then you can click on an individual operation to edit the arguments.

Here is a video walking through the system https://youtu.be/3Tf3lnuZcj8

Live edittable notebook (slow to load, runs python in WASM) https://marimo.io/p/@paddy-mullen/jlisp-in-buckaroo

I'll make a statically exported Jupyter notebook shortly

Nice work! A couple of comments

1. You don't explain what flow based programming is or when it should be used. It looks like it represents some type of data pipeline, but I'm not sure.

2. Who is this repo for? PL enthusiasts, tool builders of type $X?

3. What are operators?

4. I understand that this is supposed to execute on an Erlang cluster/VM... Could you build a JS implementation of the functions so that you could build interactive demos in a browser? The lack of multithreading in JS doesn't rally matter, you just want to be able to send 10 line examples from one function to another.

5. A fun challenge for documenting projects like this, explain it as you would to a non-technical family member. It forces you to define the other things in erlang in a very direct and simple way.

6. Make a video explaining the project.

Feel free to get in touch. We are building similar tools

Ezra Klein talks about everything bagel liberalism where the left tries to layer every cause (diversity, unions, low income housing) onto a core good idea like building more housing or transit infrastructure. It gets in the way of the goal. housing is good because otherwise people would be homeless.

https://www.nytimes.com/2023/04/02/opinion/democrats-liberal...

You can never build enough parking spots if the cost of parking is $0. Optimally managed parking charges variably so that there is always about 10% of spaces free in a block.

The entitlement of drivers to think they have a right to park a metal box wherever they want for free in the middle of the most expensive real estate in the world is staggering.