frontpage.
newsnewestaskshowjobs

Made with ♥ by @iamnishanth

Open Source @Github

fp.

Microsoft open-sources "the earliest DOS source code discovered to date"

https://arstechnica.com/gadgets/2026/04/microsoft-open-sources-the-earliest-dos-source-code-disco...
239•DamnInteresting•8h ago•61 comments

Why is Vivado 2026.1 dropping Linux support for free tier?

https://adaptivesupport.amd.com/s/question/0D5Pd00001YQLdMKAX/why-is-vivado-20261-dropping-linux-...
143•zdw•5h ago•47 comments

Scammers are abusing an internal Microsoft account to send spam links

https://techcrunch.com/2026/05/21/scammers-are-abusing-an-internal-microsoft-account-to-send-spam/
141•spike021•8h ago•62 comments

Wake up! 16b

https://hellmood.111mb.de/wake_up_16b_writeup.html
221•MaximilianEmel•9h ago•13 comments

Silk: Open-source cooperative fiber scheduler

https://github.com/ClickHouse/silk
14•animetyan•3d ago•1 comments

Converting an Integer to a Decimal String in Under Two Nanoseconds

https://onlinelibrary.wiley.com/doi/10.1002/spe.70079
29•mpweiher•4d ago•13 comments

The C64 Dead Test Font

https://www.masswerk.at/nowgobang/2026/c64-dead-test-font
45•masswerk•5h ago•4 comments

Alexander Grothendieck Revolutionized 20th-Century Mathematics

https://www.quantamagazine.org/how-alexander-grothendieck-revolutionized-20th-century-mathematics...
56•anujbans•6h ago•10 comments

Green card seekers must leave U.S. to apply, Trump administration says

https://www.nytimes.com/2026/05/22/us/politics/green-card-changes-trump.html
872•tlhunter•1d ago•1458 comments

Time to talk about my writerdeck

https://veronicaexplains.net/my-first-writerdeck/
371•hggh•14h ago•215 comments

On The <dl> (2021)

https://benmyers.dev/blog/on-the-dl/
393•ravenical•20h ago•112 comments

My two-part desk setup (2025)

https://arslan.io/2025/11/18/my-two-part-desk-setup/
282•James72689•3d ago•159 comments

Amazon Web Services – Four Years and Out

https://www.adventuresinoss.com/aws-four-years/
198•RyeCombinator•4h ago•58 comments

My I3-Emacs Integration

https://khz.ac/software/i3-integration.html
72•nosolace•10h ago•19 comments

The Art of Money Getting

https://kk.org/cooltools/book-freak-210-the-art-of-money-getting/
282•dxs•20h ago•151 comments

Sales and Dungeons: Thermal printer TTRPG utility

https://sales-and-dungeons.app/
90•hyperific•2d ago•29 comments

Judson's Last Ride

https://www.realclearpolitics.com/articles/2026/05/22/judsons_last_ride_154150.html
96•NaOH•21h ago•4 comments

Neoclassical C++: segmented iterators revisited

https://boostedcpp.net/2026/05/18/neoclassical-c-segmented-iterators-revisited-1/
26•ibobev•1d ago•2 comments

Air France and Airbus found guilty of manslaughter over 2009 plane crash

https://www.bbc.com/news/articles/czd2qmdvmq6o
88•baal80spam•13h ago•61 comments

Hengefinder: Finding when the sun aligns with your street

https://victoriaritvo.com/blog/hengefinder/
142•evakhoury•1d ago•34 comments

Key, in sight – A guide, of sorts, to keyboard customization

https://aresluna.org/key-in-sight/
6•anotherevan•4d ago•1 comments

Schlitz Is Gone, but First It's Getting One Last Hurrah

https://www.milwaukeemag.com/schlitz-is-gone/
29•NaOH•2d ago•14 comments

80386 microcode disassembled

https://www.reenigne.org/blog/80386-microcode-disassembled/
251•nand2mario•21h ago•48 comments

Reverse engineering circuitry in a Spacelab computer from 1980

https://www.righto.com/2026/05/reverse-engineering-spacelab-computer.html
102•elpocko•17h ago•21 comments

Kindle loyalists scramble as Amazon turns page on old e-readers

https://www.reuters.com/business/retail-consumer/kindle-loyalists-scramble-amazon-turns-page-old-...
165•cf100clunk•4d ago•188 comments

Byrne's Euclid

https://www.c82.net/euclid/
46•layer8•11h ago•14 comments

-​-dangerously-skip-reading-code

https://olano.dev/blog/dangerously-skip/
144•fagnerbrack•23h ago•139 comments

Buildcraft Is a Compiler Problem

https://mitander.xyz/posts/buildcraft-is-a-compiler-problem/
17•mitander•1d ago•4 comments

.NET (OK, C#) finally gets union types

https://andrewlock.net/exploring-the-dotnet-11-preview-2-dotnet-gets-union-types/
197•ingve•1d ago•192 comments

PHP's Oddities

https://flowtwo.io/post/php%27s-oddities
121•thejoeflow•4d ago•149 comments
Open in hackernews

Typed Lisp, a Primer

https://alhassy.com/TypedLisp.html
140•todsacerdoti•1y ago

Comments

codr7•1y ago
The main issue I have with CLs type checking is the clunky syntax and the fact that it looks different in different contexts.

I made an attempt to fix that for eli: https://github.com/codr7/eli#type-checking

rjsw•1y ago
Your eli looks clunky to me.
codr7•1y ago
Well, use something else.

And maybe ask yourself why you felt saying so was important to you.

dokyun•1y ago

    (the number (+ 35 7))
is a lot less clunky than

    (+ 35 7)@Numeric
codr7•1y ago
That's your opinion, I don't agree. And the other reason is I can use the same syntax wherever I want type checking.
epgui•1y ago
Opinions aside, it is objectively an increase in syntactical complexity, and many people who love lisp enjoy its relative syntactical simplicity.

Whatever is gained in exchange for this additional syntactical complexity may not be valued in the same way by everyone.

So that almost certainly explains that reaction.

codr7•1y ago
Yes, and a lot of people recognize the value of having a little bit of syntax in their Lisp.
klibertp•1y ago
Yup. Somehow, I prefer[1]:

    (funcall #~s:gi/abc/def/ "Testing abc testing abc")
to the five lines of the equivalent made with macros, function calls, and keyword arguments.

I know all the problems with reader extensions, really. I understand being cautious. But at some point, you gotta wonder: what's the point of the programmable reader when you're unwilling to add programs to it?

[1] Let over Lambda: https://letoverlambda.com/index.cl/guest/chap4.html

kazinator•1y ago
I'm reasonably happy with:

  1> (regsub #/abc/ "def" "Testing abc testing abc")
  "Testing def testing def"
HexDecOctBin•1y ago
One problem with Lisp is everything, including variable bindings, increases the nesting level making the code illegible. Last thing you want is for the type declaration to have their own nesting.
zarathustreal•1y ago
This is not necessarily true, you can pretty easily implement just about any syntax you want
dokyun•1y ago
If you hate nesting, just do this

    (defun foo (&aux bar baz)
      (setq bar (quux)
            baz (xyzzy))
      ...)
epgui•1y ago
The nesting level doesn’t necessarily impair legibility, it depends how it’s done. Nesting levels in homoiconic & referentially transparent languages have an impact more comparable to nesting levels in yaml or json than nesting levels in a language like python or javascript. The tradeoff weighs in a completely different way.

First you will usually want to write small chunks of code, instead of a large soup.

Second, you can make intentional decisions with your use of newlines in order to highlight specific aspects of the code.

I find clojure more readable than most other languages… However, bad code stands out horribly (which is actually great if you have at least one experienced engineer in the team- I’d argue there’s nothing worse than bad code that looks normal). Just like anything else, writing good lisp takes some skill.

Your specific editor and its configuration will also have a big impact on your experience.

sdsd•1y ago
You'd love threading macros in Racket: https://docs.racket-lang.org/threading/index.html

It's like Unix pipes for functions:

  (~> "hello"
    (string-ref 1)
    (char->integer))
klibertp•1y ago
Obviously, also available in CL, in Serapeum library[1]. Racket is credited in the docstring (since it's ~> instead of ->). Also, `nest` works very well for unnesting forms[2]

[1] https://github.com/ruricolist/serapeum/blob/master/control-f...

[2] https://github.com/ruricolist/serapeum/blob/master/REFERENCE...

sham1•1y ago
Aside from the points that others have raised already, this sort of deep nesting can be seen as a feature instead of as a bug, since it can force you to think about refactoring the code into being less nested.
recursivecaveat•1y ago
Are those compile-time type checks or runtime assertions?
codr7•1y ago
Mix, similar to CL but slightly more runtime atm.
norman784•1y ago
I don't particularly like the syntax for the types, but I can't also think of a better way to implement it without adding a special case in the parser/compiler for it, right now with your syntax I believe, correct me if I'm wrong, it can be implemented with a macro in any Lisp
NikkiA•1y ago
praising 'loop' in the same post as describing lisp as 'elegant' shakes head
codr7•1y ago
Some people seem to like it, and be very effective using it.

The problem is it's a walled garden, with its own quirky syntax; nothing that happens inside of loop is applicable outside, and the other way around.

shawn_w•1y ago
I feel bad for people who haven't discovered ITERATE yet.
Jtsummers•1y ago
ITERATE still breaks when you use `count` inside it, the built-in CL function. If they ever address that problem I'll get back to use it but having a time bomb in my programs isn't something I like.

Trivial example of breakage:

  (iter (for i from 1 to 10)
    (print (count i some-sequence)))
shawn_w•1y ago
Breaks how? I'm on my phone, not a computer right now and can't test, but that should call the CL function - ITERATE uses `counting` for that particular operation to avoid conflicts; see https://iterate.common-lisp.dev/doc/Gathering-Clauses.html

Or is the documentation wrong?

Jtsummers•1y ago
Apparently this is a quicklisp problem, they haven't updated the release since 2021 when it was still broken.
shawn_w•1y ago
I just grabbed the latest ITERATE source off of its gitlab repository, and, yeah, that bit is still giving an error:

      Iterate, in (COUNT I SOME-SEQUENCE): Missing value for SOME-SEQUENCE keyword
as well as

    WARNING:
       COUNT appears to be used as an ITERATE clause keyword, in this sexpression: (COUNT I SOME-SEQUENCE).
       This use is now deprecated and will cease to be supported in a future version. Please use the alternative keyword COUNTING instead. If you intended COUNT to be interpreted as a function call, instead of an ITERATE clause, you must find an alternative way of calling it, at present, perhaps by using FUNCALL or APPLY.
Have to use

    (iter (for i from 1 to 10)
        (print (funcall #'count i some-sequence)))

Guess the documentation /is/ wrong (for now, until the code finishes catching up)
Jtsummers•1y ago
Well, some-sequence was obviously an example, you'd have to fill it in with an actual sequence. Put in '(1 2 3) instead or assign something to it.

But yeah, that's still not something I intend to use if they make you work around what should be plain Common Lisp.

shawn_w•1y ago
I had a some-sequence variable defined.

(Using a literal list or vector gives a different error)

BoingBoomTschak•1y ago
It's been marked as deprecated for some time, but still needs manual removal as of now: https://gitlab.common-lisp.net/iterate/iterate/-/blob/master... (removing https://gitlab.common-lisp.net/iterate/iterate/-/blob/master... should work, I think).

Still better than the loop abomination, IMO.

kazinator•1y ago
I made a loop macro using the C preprocessor, for the Awk language.

I had to rub my own eyes to believe that such a thing is possible.

It comes with over twenty useful clauses. Clauses are programmer-definable.

Clauses can combine in parallel or nested/cross-product iteration.

https://www.kylheku.com/cgit/cppawk/about/

Jach•1y ago
I'll never understand the love for iterate. Look at these comparisons: https://github.com/sabracrolleton/sabracrolleton.github.io/b... For almost all of them, it's the same guy, just more parens. Nothing to love/hate for one or the other, it's just preference, though one is built-in.
shawn_w•1y ago
Looks more lispy because the parens. Plus it's extendable unlike LOOP, so you can make it work with your own data types. And a few other nice features like being able to collect into a vector or other sequence, not just lists.
BoingBoomTschak•1y ago
The big plus for me is that the ad-hoc if/when/do are removed in favour of the standard operators, without the horrible then/else/end/and dance.

Then you got all the life-improving goodies (in-{sequence,string,file,stream}, index-of-*, previous, etc...) that really add up to something.

kagevf•1y ago
My opinion of LOOP started to change when I read (the much maligned) "Land of Lisp" and went over that "periodic" diagram in TFA. Seeing the elements of LOOP broken down like that went a long way to get me to overcome my original aversion to it.
Jach•1y ago
Who is maligning Land of Lisp?
kagevf•1y ago
Here's an example: http://metamodular.com/Books/land-of-lisp.html
Jach•1y ago
Huh, didn't realize that beach didn't like it so strongly. Still, hardly "much maligned"... My impression was that most people enjoyed it, even though it definitely has some weaknesses and could (especially now 15 years later) use a second edition, if for no other reason than to move off CLISP to SBCL. This seems supported by its high reviews on Amazon and GoodReads. (Of course overall I liked it too, and we got the best music video about lisp out of it.) FWIW my own criticisms were largely style-based: too much of it felt like Scheme code rather than Lisp code, even outside of emphasizing/educating about the more primitive features, with lots of things like inner functions, recursion where looping would have IMO been clearer, and so much use of raw car/cdr/caadr/caddr/whatdr instead of more clearly structured structs or classes or just helper functions called intuitive things like get-foo. (The book Calendrical Calculations: The Ultimate Edition uses lists for all its data structures but helpfully creates many functions to both construct and access their parts. e.g. generic dates are a (year month day) list, but the definition and exclusive use of standard-year, standard-month, and standard-day for getting at them would let one refactor it into a class. There are also functions like gregorian-date, julian-date, and egyptian-date that have exactly the same implementation (making a list of the 3 passed params) but serve as 'typed' list constructors, and indeed could be refactored into something that carried along type information without changing other code.)
kagevf•1y ago
I like LoL alright too. I was only maybe a year or so into CL when I read it, so I didn't really notice a lot of what it's criticized for. On the one hand, I'm a little sad that I see it bagged on so much (that link from beach's site, IRC, reddit) since I felt I got decent enough value out of it, but OTOH it's good and healthy to point out problems.

The abstractions used in Calendrical Calculations sound good - and echo what I've seen elsewhere - so, based on your comment I'm now more likely to read it, so thank you for that.

Jtsummers•1y ago
https://www.cambridge.org/us/universitypress/subjects/comput...

The source code is available there.

kagevf•1y ago
Thank you, I'll check it out!
breadchris•1y ago
I have really fallen in love with LISP recently, specifically clojure. A strong type system is really needed for it to make me feel like I can confidently develop with it.
vindarel•1y ago
just get Common Lisp with this new Clojure collection and sequence API! https://github.com/dtenny/clj-coll
nextos•1y ago
A modern CL that borrows ideas from Clojure, and with a strongly typed language (Coalton) also available is indeed very appealing!
vosper•1y ago
Have you (or anyone else reading this) used Coalton? What's your experience been like? Seems quite appealing to me.
Y_Y•1y ago
The language looks amazing on paper, the install process (last I tried) was a nightmare of fighting quicklisp.
klibertp•1y ago
That's on quicklisp, not Coalton. Honestly, quicklisp is one of the worst parts of CL nowadays (right after the lack of coroutines[1], which is by far the worst offender.) It should have been replaced a long time ago. ASDF3 provides a lot of flexibility, and quicklisp uses maybe 15% of its capabilities. There are reasons why it's still so bad, but it gets less and less excusable each year :(

[1] Does anybody know how to ping Kartik Singh about the coroutines implementation in SBCL? Apparently, he made an experimental port of the green threads implementation from CMUCL, but I can't find it anywhere online, nor any obvious way to catch anyone involved. Is the mailing list the only way?

boogsbyte•1y ago
From what I heard he's not working on it anymore but the code can be found here:

https://github.com/kartik-s/sbcl/blob/coroutines/src%2Fcode%...

klibertp•1y ago
Thank you!! I was very interested in `convert-thread-to-coroutine` - I saw it on the ELS presentation, and when I went spelunking in the CMUCL codebase, I found the prototypes for `fork` and `resume`, but (probably because CMUCL is single-threaded?) nothing that would suggest how that `convert...` should look like.

Why is there so little interest in green threads/coroutines in CL community? cl-cont really isn't something to point to when asked about C10K problem... or yield/yield*... or async/await...

boogsbyte•1y ago
There's great interest for it, not little. The challenge is who can do compiler programming, add a production ready implementation as contrib SBCL package, and maintain it?
klibertp•1y ago
Hm, my impression is based on the lack of posts or articles with people demanding this to be a feature. I searched, and it just doesn't seem to come up in discussions, and when it does, it's invariably about cl-cont and problems with it.

The first implementation doesn't need to be production-ready. And the maintenance burden (along with polishing the implementation and porting to other architectures) could be shared by a few people and done over time. Having a starting point in the form of CMUCL code (already adapted to SBCL!) is the perfect opportunity for everyone interested to chime in: enough voices in favor could convince someone capable to continue the work. Yet, there are literally just 3 comments under the ESL presentation video, and it's not mentioned anywhere else...

boogsbyte•1y ago
It's mentioned on X and Discord plenty, but you're right about cl-cont.

The first few steps would be building on top of this work and reaching out to the SBCL maintainers via the mailing list to see what it takes to get this merged in.

nextos•1y ago
My experience is good, but I have only written smallish programs. Documentation is pretty polished.

Installation-wise, NixPkgs is fairly straightforward.

lucyjojo•1y ago
there is typed clojure out there if you want

https://typedclojure.org/

bmitc•1y ago
There is Typed Racket.
jodleif•1y ago
You could also consider getting into pre/post conditions and specs - helps a lot especially at points with user/data input
gitroom•1y ago
honestly i kinda love when deep dives like this pop up, makes me rethink stuff i thought i'd settled on - you think things ever get simple with lisp or it always stays quirky no matter how you do it
wizzard0•1y ago
of all things, this is the most beautifully formatted and organized LISP guide i've ever met.
eggy•1y ago
You should check out Shen[1]. It is a portable functional programming language. Optional type checking and it solves my affair with Lisp and Haskell. It is a Lisp.

[1] https://shenlanguage.org/

klibertp•1y ago
It needs a lot more good tutorials about its type system. Lacking the background in whatever subfield of math that would help here, I couldn't type my way out of a wet paper bag in it. I'd love a concise, down-to-earth, exposition of the type system "for the working programmer". It's just so different than anything else I know (from Haskell to Prolog) that I had a really hard time understanding Shen's type system.
eggy•1y ago
You're right: Shen's mathematical underpinnings (sequent calculus, dependent type theory) can intimidate programmers without a formal logic background. I bought the "The Book of Shen" (TBOS) revision 1 and revision 3. Revision 4 is available on the website. It's a great book with some CS history, logic, and development of Shen from Qi as well as how everything works in Shen including the type system.

Shen uses a dependently typed Sequent-Calculus based Type System (SCTS). It uses type rules vs. type classes, and type checking is optional, you can turn it on or off. Haskell's type inference makes things a bit simpler, and is a battle-tested static type system with excellent type inference which lends itself better for functional programming and large-scale software engineering (for the moment). Shen's TC is more expressive, but requires more effort.

Aditya Siram has some old but goody YT videos on Shen.

klibertp•1y ago
I wanted to buy it - I don't remember exactly, but I think I couldn't find an e-book version, and the paper one was expensive and didn't even ship to my country :( I hope to be wrong on that, though, do you know if there's an ebook available from somewhere?
eggy•1y ago
Other than the online version (4th edition), I don't know of any other place to get it. Yes, the paperback was expensive, but I bought it anyway. It proved to be very informative and more substantive than I had thought. I believe the 5th edition is almost ready for publication.
klibertp•1y ago
> Other than the online version

I'm an idiot. I looked at this page: https://shenlanguage.org/TBoS/tbos.html many times, tried clicking on the table of contents, realized that chapter titles are not links, and went away thinking it's only the ToS for promotional purposes. I only realized that the page numbers are links just now. To my defense, they don't differ in color that much and lack the underline that often marks links. Still, a HUGE facepalm :D Thanks for mentioning this and making me realize my own stupidity :)

eggy•1y ago
Glad you found it. I've done much worse, believe me!

If you have any questions check out the Google Groups (no Groups comments!) for Shen. I am eager to see the 5th edition, and I will probably buy the print version.

droideqa•1y ago
I had such high hopes for Shen but the licensing shenanigans at the beginning prevented it from having a great, large open source community.
eggy•1y ago
It's resolved. I helped support it for a brief time for the SP version, which is now integrated into the latest version. You're right though, that this put many people off.