Nobody can be surprised. I don't even use discord and know of the stuff you can buy to make you seem cooler. People will buy anything to feel superior to others.
Meanwhile: vim and Emacs users, constantly installing and configuring plugins to emulate a fraction of the power of IDEs, go "just use vim/Emacs".
Did they resolve their issue with that other company? I can't remember what was going on but the owner of automattic was pissed about them not contributing back or something? Did something change?
Anything built on top of atproto I tend to distrust. Doesn't it all hinge upon the makers of bluesky hosting their central node for it to work?
EDIT: It does work. My (GNU) libc spits out version info when executed as an executable.
How does that work? There must be something above ld.so, maybe the OS? Because looking at the ELF header, ld.so is a shared library "Type: DYN (Shared object file)"
$ readelf -hl ld.so
ELF Header:
Magic: 7f 45 4c 46 02 01 01 03 00 00 00 00 00 00 00 00
Class: ELF64
Data: 2's complement, little endian
Version: 1 (current)
OS/ABI: UNIX - GNU
ABI Version: 0
Type: DYN (Shared object file)
Machine: Advanced Micro Devices X86-64
Version: 0x1
Entry point address: 0x1d780
Start of program headers: 64 (bytes into file)
Start of section headers: 256264 (bytes into file)
Flags: 0x0
Size of this header: 64 (bytes)
Size of program headers: 56 (bytes)
Number of program headers: 11
Size of section headers: 64 (bytes)
Number of section headers: 23
Section header string table index: 22
Program Headers:
Type Offset VirtAddr PhysAddr
FileSiz MemSiz Flags Align
LOAD 0x0000000000000000 0x0000000000000000 0x0000000000000000
0x0000000000000db8 0x0000000000000db8 R 0x1000
LOAD 0x0000000000001000 0x0000000000001000 0x0000000000001000
0x0000000000029435 0x0000000000029435 R E 0x1000
LOAD 0x000000000002b000 0x000000000002b000 0x000000000002b000
0x000000000000a8c0 0x000000000000a8c0 R 0x1000
LOAD 0x00000000000362e0 0x00000000000362e0 0x00000000000362e0
0x0000000000002e24 0x0000000000003000 RW 0x1000
DYNAMIC 0x0000000000037e80 0x0000000000037e80 0x0000000000037e80
0x0000000000000180 0x0000000000000180 RW 0x8
NOTE 0x00000000000002a8 0x00000000000002a8 0x00000000000002a8
0x0000000000000040 0x0000000000000040 R 0x8
NOTE 0x00000000000002e8 0x00000000000002e8 0x00000000000002e8
0x0000000000000024 0x0000000000000024 R 0x4
GNU_PROPERTY 0x00000000000002a8 0x00000000000002a8 0x00000000000002a8
0x0000000000000040 0x0000000000000040 R 0x8
GNU_EH_FRAME 0x0000000000031718 0x0000000000031718 0x0000000000031718
0x00000000000009b4 0x00000000000009b4 R 0x4
GNU_STACK 0x0000000000000000 0x0000000000000000 0x0000000000000000
0x0000000000000000 0x0000000000000000 RW 0x10
GNU_RELRO 0x00000000000362e0 0x00000000000362e0 0x00000000000362e0
0x0000000000001d20 0x0000000000001d20 R 0x1
The program headers don't have interpreter information either. Compare that to ls "Type: EXEC (Executable file)".
$ readelf -hl ls
ELF Header:
Magic: 7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00
Class: ELF64
Data: 2's complement, little endian
Version: 1 (current)
OS/ABI: UNIX - System V
ABI Version: 0
Type: EXEC (Executable file)
Machine: Advanced Micro Devices X86-64
Version: 0x1
Entry point address: 0x40b6e0
Start of program headers: 64 (bytes into file)
Start of section headers: 1473672 (bytes into file)
Flags: 0x0
Size of this header: 64 (bytes)
Size of program headers: 56 (bytes)
Number of program headers: 14
Size of section headers: 64 (bytes)
Number of section headers: 32
Section header string table index: 31
Program Headers:
Type Offset VirtAddr PhysAddr
FileSiz MemSiz Flags Align
PHDR 0x0000000000000040 0x0000000000400040 0x0000000000400040
0x0000000000000310 0x0000000000000310 R 0x8
INTERP 0x00000000000003b4 0x00000000004003b4 0x00000000004003b4
0x0000000000000053 0x0000000000000053 R 0x1
LOAD 0x0000000000000000 0x0000000000400000 0x0000000000400000
0x0000000000007570 0x0000000000007570 R 0x1000
LOAD 0x0000000000008000 0x0000000000408000 0x0000000000408000
0x00000000000decb1 0x00000000000decb1 R E 0x1000
LOAD 0x00000000000e7000 0x00000000004e7000 0x00000000004e7000
0x00000000000553a0 0x00000000000553a0 R 0x1000
LOAD 0x000000000013c9c8 0x000000000053d9c8 0x000000000053d9c8
0x000000000000d01c 0x0000000000024748 RW 0x1000
DYNAMIC 0x0000000000148080 0x0000000000549080 0x0000000000549080
0x0000000000000250 0x0000000000000250 RW 0x8
NOTE 0x0000000000000350 0x0000000000400350 0x0000000000400350
0x0000000000000040 0x0000000000000040 R 0x8
NOTE 0x0000000000000390 0x0000000000400390 0x0000000000400390
0x0000000000000024 0x0000000000000024 R 0x4
NOTE 0x000000000013c380 0x000000000053c380 0x000000000053c380
0x0000000000000020 0x0000000000000020 R 0x4
GNU_PROPERTY 0x0000000000000350 0x0000000000400350 0x0000000000400350
0x0000000000000040 0x0000000000000040 R 0x8
GNU_EH_FRAME 0x0000000000126318 0x0000000000526318 0x0000000000526318
0x0000000000002eb4 0x0000000000002eb4 R 0x4
GNU_STACK 0x0000000000000000 0x0000000000000000 0x0000000000000000
0x0000000000000000 0x0000000000000000 RW 0x10
GNU_RELRO 0x000000000013c9c8 0x000000000053d9c8 0x000000000053d9c8
0x000000000000c638 0x000000000000c638 R 0x1
It feels like somewhere in the flow there is the same thing that's happening in python just more hidden. Python seems to expose it because a file can be a library and an executable at the same time.
Can someone explain to me how to compile a C library with "main" and a program with main? How does executing a program actually work? It has an executable flag, but what actually happens in the OS when it encounters a file with an executable file? How does it know to execute "main"? Is it possible to have a library that can be called and also executed like a program?
Why? "Because everybody else does" is the most common excuse. Microsoft could be physically rawdogging people's fathers and it wouldn't matter. Belong to the "in" crowd is what matters for most people. Can't forget "idgaf" either.
You could be the most hard-left, anti-capitalist, anarchist person on the planet and still host your project on Github. In fact there are such people on Github.
Until an alternative becomes popular, early adopters of forgejo, sourcehut, radicle, and others have to proselytise their platforms. Things just don't change otherwise.
They weren't already? The amount of money they shuffle around and the megalomaniacal ideas they have that are just dreams of complete control (their own towns, cities, islands, with their own currency and so on), this cannot be surprising. I'm honestly surprised it wasn't already what they were doing.
Awesome, we're going towards a future where, just like cars, all code will look the same and do nothing really new. Maybe it will make opensource more interesting as it will be the true place for innovation and new code that isn't just copy-pasted from yet another LLM.
If you click the link, you'll see that Rust projects are no exception in their use of MIT. Do you believe other programming language communities also just care about spreading?
48
Can anybody explain why CUDA and Rocm are necessary and why OpenCL isn't the solution?
(self.programming)
It's getting more and more unhinged on LinkedIn.
It's been a while since picking up rust, but until now, most of what I've written has been CLI tools, proc macro libs, and async networking stuff. Web/application servers have been kept at arm's length while waiting for something to come around like Django.
For those not in the know, Django is a web framework written in Python. It's opinionated, extensive, has many features, and has stellar documentation. It's old too and had major problems taking advantage of (back them) python's new async capabilities as well as "new" technologies like WebSockets. Popular frameworks popped up in the meantime like Flask and FastAPI that do use new technologies and python language features like type hints, however nothing has really come to be quite like Django.
Django's ORM
As usual, there are camps when it comes to this, but I'm in the "keep SQL away from me" or "one language for all" camp. Django's ORM does a mighty fine job of doing so. It's possible to write a django application without ever seeing a line of SQL. It helps me immensely to just think about models, application logic, and presentation.
Django allows defining your models in python, generating and handling database migrations, making complex queries of 1-1, 1-n, m-n relations without an SQL syntax, storing objects, locking rows, optimising queries (again without knowing SQL), and much more.
Queries
My favorite, powerful query simplifications are QuerySet.select_related() and QuerySet.prefetch_related().
An example of Queryset.select_related:
This is useful for a tree of 1-n objects. An example from the documentation: a Book has an author (foreignkey) which is a Person (1-n), with a hometown (foreignkey) that is a City (1-n). An author can have written many books (n-1), a city can have many people (1-n).
Say you wanted to find 10 books from an author that lives in "Marrakesh" with the associated objects (Book, Person, City). In Django that's
# Hits the database with joins to the author and hometown tables.
books = Book.objects
.filter(author_hometown__name="Marrakesh")
.select_related("author__hometown")[:10]
book = book[0]
person = book.author # Doesn't hit the database.
city = person.hometown # Doesn't hit the database.
QuerySet.prefetch_related() does the same for m-n / many-to-many relationships and some other queries (see doc). No messing around with SQL, just python.
Migrations
The ORM also takes care of generating and managing migrations for you. To me, that's a major plus as it offloads the need for me to think about whether a specific type exists in the DB of choice. Most of the time django will handle it transparently. There are even django extensions / apps to optimise more SQL query generation like adding views, or choosing which index to use for a specific type or table, and so on.
Django's documentation
If I'm not mistaken, it follows the diátaxis method of documentation
which fits the project very well and allows getting started with django very easily as well as finding good, low-level, in-depth information quickly. Many projects have documentation but it's everywhere and nowhere in terms of location (where to find specific things) and depth (high-level vs low-level), making it less optimal for beginners and experts alike. If you want to step up your documentation game, do give diátaxis a shot.
What prompted this
I'm currently 3 days into exploring the rust web framework ecosystem and banging my head against it. It's very commendable what people have written in their free time and shared with the world, so I will not disparage any projects here. It would just be really cool if a django-like, batteries-included project started or reached production quality sometime. The closest candidate I found is Cot.
Cot started in June 2024 and is a long way from django's level but has already grown to something quite impressive. If time allowed it and the project weren't on GitHub, and had a matrix chatroom, it would surely get contributions from me. Here's the announcement on the main dev's blog, which reflects some of my frustrations with the current web framework ecosystem in Rust.
Until Cot is ready, I'll probably be using axum for application server, diesel for the DB-glue, and possibly leptos, yew, or just plain Rinja. Unless of course somebody knows of a django-like web framework in rust that isn't on awesome-rust...
Where are you applying? Is it only locally for in office or hybrid jobs? I said "fuck it" and applied worldwide: Japan, Singapore, Portugal, Switzerland, Australia, Thailand, Canada, South Africa, Fiji, etc. You'd be surprised how many are actually willing to provide a work visa for candidates.
Also, if you're willing to move or just work remotely, there are many more options. I was open to seeing a different place and so far that's been to my advantage.
Relocateme, ethicaljobs, jobsforgood, ratracerebellion, 4daywork(week), offerzen (post your profile and let employers find you), remote dot com, and other sites all make this kind of stuff possible.
Anti Commercial-AI license