jsource
swift-evolution
jsource | swift-evolution | |
---|---|---|
18 | 125 | |
640 | 15,030 | |
1.4% | 0.5% | |
9.6 | 9.7 | |
9 days ago | 3 days ago | |
C | Markdown | |
GNU General Public License v3.0 or later | Apache License 2.0 |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
jsource
-
Crafting Self-Evident Code with D
The one other example I know that morphs the language to that extent and to the detriment of readability by C programmers is the J interpreter[1,2]. But, once again, nobody (that I’ve read) claims it’s good or clear C. (Good C for those who speak J, maybe; I wouldn’t know.)
For a way to morph C syntax that does make things better, see libmill[3].
[1] https://code.jsoftware.com/wiki/Essays/Incunabulum
[2] https://github.com/jsoftware/jsource/tree/master/jsrc
[3] https://250bpm.com/blog:56/
- Show HN: Gemini client in 100 lines of C
-
Can anyone identify what this code does ?
Oh damn Whitney C representation.
-
C is the most dysfunctional non-esolang on the planet, precisely because everyone insisted on it being "just simple pointers"
I develop J btw
-
Want cleaner code? Use the rule of six
No, it was rhetorical, because it's obviously (to an APL-family programmer), not bad!
Your cultural prejudice is showing. There are good reasons APL is written the way it is, and this example is simply bringing those benefits to C by writing it in the dense APL style. There are other APL derivatives, like J[1] that are written the same way. These projects are well-maintained. They aren't collapsing under a load of technical debt. The style works. To them, it's clean code.
[1]: https://github.com/jsoftware/jsource
-
Ask HN: Is this how anyone programs?
Recently, I wanted to write a simple piece of code in J, but immediately found a bug. I went ahead to fetch the source to see if I can fix it. But, hell no. I couldn't believe my eyes. Is this how someone programs, really? I just can't believe it didn't go through some kind of obfuscator.
Here are some samples, but almost anything in the repository is beyond me:
https://github.com/jsoftware/jsource/blob/master/jsrc/xo.c
-
Jd
You can view the code, but is not open source: https://github.com/jsoftware/jsource/blob/master/license.txt
-
Someone earlier linked to Arthur Whitney's style of coding in the comments. Can we discuss this further? I am disturbed by what I saw.
This is the same dense style used in J.
-
Why does old C code often declare functions or global variables in the scope it's used, rather than at the top of a source file or a header file?
All-in-all this example doesn't seem too bad. It's clear what happens and is easy to follow. If you wan't to see something remarkably terribly, check out Whitney style. It's used in APL/J/K family interpreters. Keep in mind, financial institutions run that code.
- Ask HN: Examples of Unusual Code Formatting Styles?
swift-evolution
-
Swift's native Clocks are inefficient
According to their changelog[0], Clock was added to the standard library with Swift 5.7, which shipped in 2022, at the same time as iOS 16. It looks like static linking by default was approved[1] but development stalled[2].
I expect that it's as simple as that: It's supported on iOS 16+ because it's dynamically linked by default, against a system-wide version of the standard library. You can probably try to statically link newer versions on old OS versions, or maybe ship a newer version of the standard library and dynamically link against that, but I have no idea how well those paths are supported.
0. https://github.com/apple/swift/blob/main/CHANGELOG.md
1. https://github.com/apple/swift-evolution/blob/main/proposals...
2. https://github.com/apple/swift-package-manager/pull/3905
-
Byte-Sized Swift: Building Tiny Games for the Playdate
[A Vision for Embedded Swift](https://github.com/apple/swift-evolution/blob/main/visions/e...) has the details on this new build mode and is quite interesting.
> Effectively, there will be two bottom layers of Swift, and the lower one, “non-allocating” Embedded Swift, will necessarily be a more restricted compilation mode (e.g. classes will be disallowed as they fundamentally require heap allocations) and likely to be used only in very specialized use cases. “Allocating” Embedded Swift should allow classes and other language facilities that rely on the heap (e.g. indirect enums).
Also, this seems to maybe hint at the Swift runtime eventually being reimplemented in non-allocating Embedded Swift rather than the C++ (?) that it uses now:
> The Swift runtime APIs will be provided as an implementation that’s optimized for small codesize and will be available as a static library in the toolchain for common CPU architectures. Interestingly, it’s possible to write that implementation in “non-allocating” Baremetal Swift.
-
Borrow Checking Without Lifetimes
I may be out of my depth here as I've only casually used Rust, but this seems similar to Swift's proposed lifetime dependencies[1]. They're not in the type system formally so maybe they're closer to poloneius work
[1]: https://github.com/apple/swift-evolution/blob/3055becc53a3c3...
-
Functional Ownership Through Fractional Uniqueness
Swift recently adopted a region-based approach for safe concurrency that builds on Milano et al’s ideas: https://github.com/apple/swift-evolution/blob/main/proposals...
- Swift-evolution/proposals/0373-vars-without-limits-in-result-builders.md
- The Swift proposal that removed the ++ and –- operators (2017)
-
Crafting Self-Evident Code with D
No, it's not. Refcounting CAN be a garbage collection algorithm, but in Swift it's deterministic and done at compile time. Not to mention recently added support for non-copyable types that enforces unique ownership: https://github.com/apple/swift-evolution/blob/main/proposals...
- Statically link Swift runtime libraries by default on supported platforms
- (5.9) What is the point of a SerialExecutor that can silently re-order jobs?
-
Mac shipments grow 10%, as all major PC brands see downturns.
You can stackallocate buffers with unsafe Swift but it's not exactly fun to use. https://github.com/apple/swift-evolution/blob/main/proposals/0322-temporary-buffers.md
What are some alternatives?
tinygrad - You like pytorch? You like micrograd? You love tinygrad! ❤️ [Moved to: https://github.com/tinygrad/tinygrad]
compose-multiplatform - Compose Multiplatform, a modern UI framework for Kotlin that makes building performant and beautiful user interfaces easy and enjoyable.
b-decoded - arthur whitney's b interpreter translated into a more traditional flavor of C
foundationdb - FoundationDB - the open source, distributed, transactional key-value store
ancient-c-compilers - Very old C compilers
kotlinx-datetime - KotlinX multiplatform date/time library
ZLib - A massively spiffy yet delicately unobtrusive compression library.
okio - A modern I/O library for Android, Java, and Kotlin Multiplatform.
kdb - Companion files to kdb+ and q
PeopleInSpace - Kotlin Multiplatform project with SwiftUI, Jetpack Compose, Compose for Wear, Compose for Desktop, Compose for Web and Kotlin/JS + React clients along with Ktor backend.
boot - Build tooling for Clojure.
swift-algorithms - Commonly used sequence and collection algorithms for Swift