dharmaturtle

> Ron and Laurent discuss the tradeoffs between working in a text editor and a Jupyter Notebook

F#, basically OCaml on dotnet, has good support for notebooks: https://www.compositional-it.com/news-blog/a-brief-introduct...

I use it all the time when prototyping/scripting. Much more fun to use than the standard REPL.

A video of it in action: https://channel9.msdn.com/Shows/VS-Code-Livestreams/net-Inte...

This [1] is a nice AHK window manager. Win+UpLeft moves the current window, Win+DownRight resizes it, and WinSpace centers. Makes it easy to compose resizing & moving to get exactly what you need. Vertical is 50% increments, horizontal has increments at 0%, 33%, 50%, 66%, and 100%, though ofc you can customize cause its AHK. Only works with 1 monitor though.

[1] https://autohotkey.com/board/topic/79338-simple-window-posit...

P.S. ty for LangExt :)

4k 39" 16:9 here, but it's a TV not a monitor. I'd also love more height, but I think we're stuck with 16:9's past 35" since monitors past this size aren't popular. While we're wishing, I'd also like curved please :)

I'm use Windows so AutoHotKey is my window manager: https://autohotkey.com/board/topic/79338-simple-window-posit...

Usually my main window is an IDE and it takes 50% of the center, and I'll have miscellaneous windows off to the left and right peeking out from behind it. Creating shortcuts to specific programs (also to minimize/maximize/close them) is also helpful as mousing to the taskbar is just not efficient.

I'm curious about your decision to use robotic arms. Why arms and not, say, (electro)magnets? Or perhaps both - they aren't mutually exclusive. Or maybe you are doing both...

For the lazy (works for me with uBlock Origin & Chrome):

1. https://easylist.to/

2. Click "add it to your ad blocker" on the relevant list.

3. Click subscribe in the upper right corner

Thanks for the reply - what you say makes a lot of sense. I watched Rich's talk on Async and was like... "cool so `core.async` follows this pattern right?!" ...not quite.

I'll check out your other links though, much appreciated. Also hearing that I should just be okay with blocking is well, good to hear explicitly.

> but you’ve lost the benefits of a simple date

I see what you mean - thanks!

> you could further choose to turn it off or to substitute your own types / schema without making changes to the system / code

This is still unclear to me. How can you make changes (turning off gradual typing/substituting your own schema) without making changes to code?

Hey, so my my career path has been C# (many years) -> F# (couple years) -> Clojure (3 months). I understand multithreading primarily through the lens of async/await, and have been having trouble fully grokking the Clojure's multithreading. One of the commandments of async/await is don't block: https://blog.stephencleary.com/2012/07/dont-block-on-async-c...

Which is why the async monad tends to infect everything. Clojure, as far as I can tell so far, doesn't support anything similar to computation expressions. So I'm guessing your "poked at it a couple times" was something like calling `pmap` and/or blocking a future? All my multithreaded Clojure code quickly blocks the thread... and I can't tell if this is idiomatic or if there's a better way.

> E.g. you could express something like "the parameter must be a date within the next 5 business days" - there's no static restriction

Hm, I don't follow. If I were to write this in F#, there would be a type `Within5BusinessDays` with a private constructor that exposes one function/method `tryCreate` which returns a discriminated union: either an `Ok` of the `Within5BusinessDays` type, or an `Error` type with some error message. Once I have the type, I can then compose it with whatever and send it wherever and since F# records are immutable, I won't have to worry about invariants not holding. And since it's a type, I have the compiler/type system on my side to help with correctness.

(Side note, this is a bad example since the type can become invalid after literally 1 second... but since Clojure has the same problem I'm just running with it.)

I'm still learning Clojure (only a few months into it), but if I were to to write a spec, I'd have to specify what to do do if the spec failed to conform - same as returning the `Error` case in F#.

> i could swap out your spec for my spec so that would be 1:n but those specs may make sense to compose in other data use cases so really it's m:n rather than 1:1

Sorry, but I'm still not following - I believe you can do the same with types, especially if the type system support generics.

Ah, well if you're going to shit on Go/Java/C#/C++ I won't stop you :)

You might try re-reading it with some charity - the example's purpose isn't to teach the `Maybe` monad, but to remove the redundant check. To go into what `bind` does would be a diversion from the main topic (parsing vs validating).

FWIW SPJ has called this blog's author a "genius" so... I think they do know how `Maybe` works. https://gitlab.haskell.org/ghc/ghc/-/issues/18044#note_26617...

A demo of a SQL type provider in action: https://youtu.be/RK3IGYNZDPA?t=2539

It requires a bit of elbow grease to make it work with a CICD system... but it works :D

> What you get here goes way beyond what a strict, static type systems gets you, such as arbitrary predicate validation,

Is this refinement types, which most static languages provide? https://en.wikipedia.org/wiki/Refinement_type

> freely composable schemas,

My understanding is that you can compose types (and objects) https://en.wikipedia.org/wiki/Object_composition

I'm assuming that types are isomorphic with schemas for the purposes of this discussion.

> automated instrumentation

I know that C# and F# support automated instrumentation/middleware.

> and property testing. You simply do not have that in a static world.

QuickCheck has entered the chat: https://en.wikipedia.org/wiki/QuickCheck

I've slowly stopped playing video games after college... but I deleted my Blizzard account after Blizzard doubled down on Blitzchung. Banning the casters for six months... that still gets me riled up. It makes zero sense to ban the casters for the player's conduct.

Java/Python/C# were my first languages, and worked in them for over a decade.

I learned F# in a ~year, and then found a Clojure job. I _never_ want to go back to OO.

> They write stories about events that are embarrassing or damaging to named individuals all the time (e.g. reporting on the police blotter), even though I'm sure all those people would have preferred their identities be kept secret.

Good point, but notably that info is literally in the public domain. Journalists aren't setting up sting operations to unmask Banksy, and if they did they'd get rightly criticized for it.

> Doxxing is entirely particular to the internet, because IRL people typically use their real names, and almost nobody hides behind pseudonymity.

You're really, really hung up on the fact that "doxxing" is medium specific, which is why I'm trying to move it to IRL activity. Honestly I think the fact that Metz can't respect the conventions/culture of the medium he's reporting on is another blow against his credability/employability.

> He wasn't a source, he was a subject.

I understand the difference. I'm responding to this line in particular:

> doxxing does not exist outside of some particular very online spaces

Journalists do understand that someone may want to keep their identity secret, which is what doxxing is. While doxxing as a term is particular to the internet, it - at least as a concept - predates the internet.

> because doxxing does not exist outside of some particular very online spaces

Journalism very much has the idea of protecting their sources. The NYT, for whatever reason, didn't feel like protecting Scott.

They still employ Cade Metz, who doxxed Scott Alexander.

https://astralcodexten.substack.com/p/statement-on-new-york-...

My opinion of the NYT plummeted when they doxxed Scott Alexander

https://astralcodexten.substack.com/p/statement-on-new-york-...

OLED burn in is the main reason I haven't bought one to use as a monitor. The taskbar is probably gonna burn in as it just doesn't change much.

Also Discord, though a bit smaller than the Slack: https://discord.gg/R6n7c54

Arguably that's a "good problem to have". A startup in its early days pretty much requires all its engineers to punch above their weight class. Every company slows down/averages out as once it starts to scale.

When I was interviewing for F# positions, I was getting offers that were ~50% more than what I was getting for C# positions. YMMV of course. The quality of engineering at the F# positions was also obviously higher.

AlexNet came out 2012, less less than 10 years ago.

Going from AlexNet to, say, self driving cars in under ten years sounds insane to me. This is only the beginning.

Do you think he writes essays to make money?

> we can't automate the math, yet

This exists: https://en.wikipedia.org/wiki/Automated_theorem_proving

> I also hate that the anki shared decks web site does not encourage collaboration...

Dude, I'm building exactly this. I'm not basing it on git for various reasons, but I am using event sourcing, and git is basically event sourcing for code. My system will (eventually) allow pull requests, comments, upvotes/downvotes, and all kinds of community shenanigans on flash cards. It's months away from release... but here's the repo if you wanna have a look: https://github.com/dharmaturtle/cardoverflow

Nice. Just checking, did you not go with firebase/couchdb/pouchdb due to pricing?

It's open source so you can just copy the spec. The community's built a syncing server here: https://github.com/ankicommunity/anki-sync-server

There's also a really interesting templating library that generates cards for Anki: https://closetengine.com/