bsrkf

When I look at a programming language site, especially for a "new" language, I want a quick way to navigate to a reasonably sized decent code sample, ideally documented, showing off significant language features, idiomatic syntax and usage patterns etc...

Sites which do this well (just from the top of my head):

  https://odin-lang.org/
    immediate code sample visible
    "See the Full Demo"
    "See More Examples"

  https://ziglang.org/
    immediate code sample
    scroll down a bit, "More Code Samples"

Here on red-lang.org... I can barely find a consecutive meaningful chunk of code... ?

  "Getting Started" Nope
  "Documentation" Nope
  "Official Documentation" link to github
    https://github.com/red/docs/blob/master/en/SUMMARY.adoc
  "Home"
    merely a chronologically sorted blog
    newest entry links to 50 line "script" by chance
      showing off multi-monitor support
      (doesn't seem like a super helpful sample)

?

bsrkf

last yeardiscuss

  "Perhaps this explains why Odin has found such widespread usage and popularity. /s"

What an unnecessarily snark and dismissive comment to make about someone's work.

  - I'd say within a certain niche Odin is becoming well known and gets its use
  - you do realize using an `Odin package` is putting a program into a sub-folder and that's it
  - It comes with a rich stdlib + vendor libraries out of the box
  - and isn't it kind of up to the creators how to design and promote their language

I'd even argue it's laudable a language doesn't promote itself as a "fixes everything use me at all costs" kind of technology. The creator himself tells people it might not be the right tool for them/their use case, encourages them to try other languages too, sometimes outright tells them Odin doesn't fit their needs and xyz would probably do better.

Odin is pragmatic & opinionated in its language design and goal. Maybe the lack of a package manager is the basis for you to disregard a programming language, for plenty of others (and likely more Odin's target group) it's the least of their concerns when choosing a language.

bsrkf

last yeardiscuss

Can't benefit from them patching a security issue, but don't suffer from

  - them breaking something
  - a supply chain attack
  - them making a change which breaks your program
  - you having accidentally relied on a bug or an unintended behavior of their code
    (which they may fix at any moment)
  - many unneeded LOC in your codebase
  - absolution of ownership
    - relying on a dependency versus having written it yourself
    - in the latter case you'll automatically take responsibility
    - think much more about code's security/quality
    - have the knowledge to fix it and know exactly where to
      (in your 35-lines of code you yourself wrote)
  - more burdensome upgrades of your software
  - longer compilation speeds
  - having to monitor their program
    - is it abandoned, ownership transferred to dubious party
    - did the maintainer have a late night drunken stupor accepting bad pull requests
    - did they react to a CVE or not
    - did they change the license
    - do they have a license but added their own problematic paragraph
    - does the program "develop badly"
      (change its target scope in any problematic way)
      (take on more and more bloat, more unneeded functionality)
  - having worse of an overview of your total dependencies 
    (since they may themselves rely on further crates you don't expect)
  - ...

what's the trade-off now?

bsrkf

last yeardiscuss

C is liked particularly, even considering all its shortcomings, for being a relatively limited language in scope, being raw but flexible.

D's scope seems to go far beyond what your average C programmer would want in a language; "use only 15% of the language and you'll be fine" (paraphrasing: "use only the 'better-C' subset", if that is what you meant, and it does seem to be a subset of D) seems a weird proposition; it still complicates things, as in collaboration, idiomatic feel and look of code, the amount of knowledge required to be competent in the language, complexity of a compiler implementation, portability of code etc... and by that logic you'd have to prefer C++ over C as well (since a lot of C is valid C++), or prefer C plus one safety feature added over C; but the "rawness"/limited scope/small size/procedural nature of C is what's appealing for many to begin with.

I for one think that a proper C replacement (C's strength also being the simplicity in which to implement a compiler for example, being the reason it's so ubiquitous in the embedded world) will be a much more limited proposition than D is.

Edit: And having been curious, even "Better-C" still has things many C-programmers wouldn't particularly like. Going by things listed here https://en.wikipedia.org/wiki/D_(programming_language)

  RAII
  Full metaprogramming
  Nested functions, nested structs, delegates and lambdas
  Member functions, constructors, destructors, operating overloading, etc.
  ...

Where to draw the line will be different person to person, but D doesn't seem to be a language "in the spirit of C", or a "modern version of it", at all.

Viewing it as a C++ alternative makes much more sense. A `Better-C` "limit yourself to a subset of the language" compiler flag doesn't change that much.

bsrkf

last yeardiscuss

^ and this person (no affiliation) has a much "truer" C alternative in the making, just for everyone's information: https://c3-lang.org/

Haven't gotten around to trying it out, but skimmed the documents a lot at one point. Always try to keep tabs on it, doesn't get the love it should.

bsrkf

last yeardiscuss

Excuse me for not having much to add to the discussion but two interesting references for people to check out, if so inclined of course:

a) Ginger Bill (the Odin language creator, no affiliation) stated on a podcast that Odin will never have an official pkg manager, since what they're, in his opinion, mainly automating is dependency hell, and this being one of the main reasons for rising software complexity and lower software quality; see https://www.youtube.com/watch?v=fYUruq352yE&t=11m26s (timestamped to the correct position) (they mention Rust explicitly as an example)

b) another programmer rather seriously worried about software quality/complexity is Jonathan Blow, who's talk "Preventing the Collapse of Civilization" is worth watching in my opinion: https://www.youtube.com/watch?v=ZSRHeXYDLko (it's not talking about package managers specifically, but is on topic regarding software complexity/quality as a whole)

Addendum: And sorry, I feel like almost everyone knows this xkcd by now, but since no one so far seems to have posted it; "obligatory xkcd reference": https://imgs.xkcd.com/comics/dependency_2x.png

bsrkf

last yeardiscuss

Seems needlessly harsh and also misplaced in some way. Zig is super non-ergonomic to any C-developer, and its explicitness at all costs is also non-C-like (meaning a rather big shift for someone actually liking C). Rust is a completely different beast altogether.

Odin is a rather simple, performant, pragmatic, procedural language, fixing especially things in C with regards to its type system and infrastructure (such as packages), adding niceties such as `defer` while being at it. I, as a C programmer, have it far higher up my list of languages to try than Zig or Rust by a rather large margin.

btw: "C alternative means a language that will last for 50 years" seems a snide that could be applied to any language less than 20 years old? I'm not sure what that's concretely meant to criticize here? Is Zig more a 50-year language than Odin, if so how? Odin is used for rather serious commercial products at JangaFX btw: https://jangafx.com/ and is quite beloved by some people using it.

bsrkf

last yeardiscuss

I always thought it was more akin to a C++ than a C alternative, and reading https://en.wikipedia.org/wiki/D_(programming_language) seems to rather confirm this notion:

  "originated as a re-engineering of C++"
  "influenced by Java, Python, Ruby, C#, and Eiffel"
  "design by contract, ranges, built-in container iteration concepts, and type inference"
  "array slicing, nested functions and lazy evaluation."
  "Java-style single inheritance with interfaces and mixins"
  "function overloading and operator overloading"
  "supports five main programming paradigms" (including OOP)
  ... et cetera

Though it does support things like in-line assembly and the like, I'm sure most C programmers would pass on it, as a C-alternative, based on those factoids.

bsrkf

last yeardiscuss

Thanks for the answer, very nice of you to take the time even hours after.

Guess it makes sense; I'm self taught myself, but thought academically taught developers should have a leg up in theory and mathematics, at the same time though, at one point I considered further formal education for myself (in at least paid courses and such), I realized that I don't think there's much I can't teach myself with the resources available (which includes high quality university lectures which are available for free).

Thanks for your perspective.

bsrkf

last yeardiscuss

Nowhere have I claimed that the whole product would need (nor should) be fully open source and why wouldn't non-US wages help?

Assuming it takes me X-amount of software engineering hours to produce an alpha version of a given product and now let's imagine a rented office space plus four developers; consider renting in a major US city, and paying competitive US-major-city-wages versus doing so in a significantly smaller city in Eastern Europe (Czechoslovakia, Romania, Estonia).

In both cases you could develop an English-Language version of your product for global use and you can distribute software cheaply over the internet; you'd still charge customers in the US US-prices, yet would have saved on development costs.

I'm sure this comes with its own set of difficulties, especially regarding US business customers, but initially it could be an advantage in certain scenarios.

There also seems to be a current push towards non-US (sometimes even specifically from-EU) products in tech, which might give one an interesting market position, albeit I'm lacking details here, and it's yet to pan out how viable this trend is long-term of course.

bsrkf

last yeardiscuss

Makes sense, out of all the potential differentiators the source of skill attainment simply isn't the necessarily dominant one. Thanks for the answer :)

bsrkf

last yeardiscuss

Since this thread, rightfully so (and in full agreement), has people complain about the bloat of today's software stack, is it only me in thinking there may be sincere potential profit streams for high quality paid software?

I would happily pay for software that

  was high-quality
  was fast
  was privacy preserving
  had sane defaults
  had/provided reasonable support/insight
    (forum and developer blog)
  had a fair pricing models
    (non-subscription, x-years of updates etc)

as in

  an e-mail client
  an office suite
  a scheduler
    (scheduling learning, tasks, various deadlines, calendar, ...)
  photo/video editor
    (wouldn't need to be of the scope of a professional suite)
  a browser
    (earnestly, one that wasn't a mere chrome re-skin, wasn't run by a bloated paid by Google organization like Mozilla, and would take fingerprinting prevention and privacy seriously)
  ...

or am I underestimating the problem? How many full-time developers working how many hours, building on open-source software where sensible (as in you wouldn't hand-roll your own cryptography, networking protocol implementations, GUI libraries) would it take, for e.g. a good cross-compatible Desktop E-Mail Client? (there's little in terms of software that I hate more than Outlook)

And given competitive non-US, maybe even non EU-wages for such developers, how many 'customers' with fair pricing would such a company/startup need?

You could open-source part of your stack (as in singular libraries) for exposure and good will, could maybe offer free-tiered versions, potential fair pricing models could be similar to Sublime's https://www.sublimehq.com/store/text you could build upon technologies people are exited about and willing to take pay cuts for if that's what they could work in (Odin, Zig, Rust, ...) etc...

Even considering vendor lock in, market dominance of existing solutions, the dominance of smartphones over desktops, isn't there still a viable market? Maybe what's left is even more so, given Desktop use seems (besides gamers) consist (to a significant extent) of power users, semi-professionals/professionals & businesses?

And, even though this place here is of course a highly niche bubble, the plights of modern's software lack of quality are real and I'm sure felt beyond us.

bsrkf

last yeardiscuss

Hope this doesn't come off as disrespectful, as in that I don't believe you, but out of personal interest, would you consider expanding on that? I'd love to hear about the particular example you were thinking of, or in what ways self-taught coders surprised you over academically-taught ones, if you've had experience working with both over a meaningful span of time. Also, if the case, in what ways self-taught coders were/are maybe lacking on average.

If you've ever given answers to that in another comments on HN or elsewhere, feel free to link.

Submissions

IEEE robot videos (video Friday)

RustyDL: A Program Logic for Rust

comments