We write operating systems in C because it’s a thin veneer over assembly and coding in assembly is really hard. We use C++ instead of other languages because of its C interop.
Erlang is a really good fit for concurrency so that’s one of the few languages that’s used where it is for its technical merits.
Python is used for academic work solely because it’s easy to learn and easy to get started with so a lot of colleges used python to teach engineers/scientists programming. Python became the language of academia because that’s what the people in academia knew. If colleges had adopted Ruby or Lia for their Programming for non CS majors 101 classes instead, Lua or Ruby would be the language of academia.
Don’t disagree with a lot of the rest of your post, but this is a real, genuine virtue and ought not to be lightly dismissed.
I've taught Haskell at an university and almost none of the students ever found the model of computation natural. I think we humans simply find following a series of steps easier than reasoning in an abstract mathematical sense.
That being said, I absolutely see the value of the latter, and consider it a good thing that functional concepts are gaining popularity in imperative languages.
They seem naturally sequential and an imperative to me.
I can't imagine how a list of instructions would be clearer in haskell.
cook meat sauce = do
pan <- getPan
addTo pan meat
cookFor pan 10
addTo pan sauce
cookFor pan 3
food <- contents pan
pure foodAlthough written in an imperative style and thus superficially similar, the haskell differs in that it is referentially transparent.
I think that makes it objectively clearer, because it implies certain guarantees that nothing will surprise the reader.
It is not at all obvious that this is truly the case. If it was the case, why didn't humans intuitively develop mathematics from a computational foundation? It took centuries before we made the leap from mathematical abstractions to Turing machines, and the two are (in some great general sense) isomorphic.
So, you are right regarding the mindset of human philosophers, but that is not the sort of problems OP's students were tasked with solving.
Javascript is as easy to learn as any language, like understanding the syntax of a loop or an if-statement.
But to do anything practical at all, I'd say you quickly bump into a jungle of libraries you need for everything, and then it is just as complicated as any other language, or more. The javascript ecosystem is a nightmare.
Node makes this a lot harder, the simplest way to have interactivity is the readline library, and that requires you to understand functions, closures and the idea of a callback and why one is needed.
Then there's the "R way" of learning Python, in a Jupyter notebook, by stringing functions from Numpy, Pandas, Matplotlib and perhaps some other libraries in your field together, with no understanding of what a loop is, because you don't really need those for basic dataframe and tensor work.
Think of all the urgent iOS, Windows etc. patches which could be avoided if the software didn’t suffer from a number of classes of avoidable vulnerabilities.
> There is a reason that we write {...} rather than in C# or F#.
So are you arguing in favor of C#/F# here? you believe it was more suited for all of these cases? I hope not.
But again, if it's neither, then this comment seems like a out-of-context straw man.
Python's REPL isn't even any good, but it does at least exist which is more than you can say for most languages.
(And there's also the fact that it's crazy popular.)
Perhaps some of the old Lisp or Smalltalk environments could rival that, but no other modern language except Julia and R, which also have Jupyter support, come even close when repl ergonomics is concerned.
Allowing your code base to run ok for 10 years, 20, 30 without change. You are talking Cobol type situations where the rest of the industry has moved on, and now your are stuck. So each individual has to judge jumping ship and migrating their systems.
Even Python took the leap and did a major revision that broke everything. But guess it had to be done.
They could ship both interpreters and communicate with RPC for all I care as long as shit still worked. Though to be fair I haven’t written a single line of Python 2 for about 10 years now.
> We do not guarantee 100% compatibility between major versions. This is true for both ASP.NET Core and the runtime itself. We intentionally make breaking changes where we believe that they are necessary to move the platform forward and the cost of the .NET ecosystem adjusting to them is low enough.
There is a major .NET release every year. Every other release is LTS with 3 years of support.
> The old .NET framework will be supported for many decades into the future
I'd guess so but Microsoft is not as clear on this as you'd wish. In all their policy documents they say it's "supported as a Windows component on the latest required update" or "Beginning with version 4.5.2 and later, .NET Framework is defined as a component of the Windows operating system (OS). Components receive the same support as their parent products, therefore, .NET Framework 4.5.2 and later follows the lifecycle policy of the underlying Windows OS on which it is installed." To me this seems to be carefully written to allow the possibility of changing that Windows component status in a Windows release. So, .NET Framework is supported as long as it is part of Windows, until it isn't.
The major releases of modern .NET are relatively painless now, there aren't that many breaking changes. This is pretty much the same as many other languages, and kinda unavoidable unless you go for an ecosystem that aims for very long term stability and is essentially frozen.
The early .NET Core releases had some annoying breaking changes, but it's very different today.
This is a true caveat for any language or framework, and is a sensible disclaimer.
But I think the author was referring to transition from “.Net Framework 4” series (since 2001 when I first used it, ~23 years ago) where Microsoft declared “.Net Framework 4.8” would be the last major version of that series. And that new developments should use the “.NET Core” series, which is now named just “.NET “.
I have a fairly large portfolio of legacy in-life systems that are stuck in limbo now, and a limited group of developers to move them to .NET 8.
We wont have to move them into isolated mode on short notice, to get them to .NET 8 but this isn’t the Microsoft of old, where backwards-compatibility is a paramount consideration.
Arguably one of the biggest downsides of c++ is that it has tons of features without there being a syntactic sugar for using them, which in turn makes them less attractive
There is so much different syntactic sugar to do the same thing that it’s becoming very difficult to onboard new devs to any slightly complex application worked on by multiple devs because invariably the codebase will consist of 3-4 syntaxes doing the same thing which can get really hard to grok.
In an ideal world C# would have gotten rid of a lot of the ceremonial code it had but unfortunately backwards compatibility means that’s not likely to happen.
I wish C# declared a preferred singular syntax for every scenario and provided IDE support to warn when that preferred syntax wasn’t being used.
Built in ones are here https://learn.microsoft.com/en-us/visualstudio/ide/visual-cs...
If you want to apply a coding style, there are lots of free tools for that even, or you could investigate something like ReSharper from jetbrains.
https://learn.microsoft.com/en-us/visualstudio/ide/code-styl...
No one is sure what problem it is trying to solve anymore.
Also the amount of people I see blowing their toes off by not understanding stuff like LINQ and when stuff is executed and materialised into memory is insane. That and entirely not understanding async and any weird side effects like things happening on other threads and losing context and all sorts. Urgh.
Im sure C# version 22 or whatever it's on now will allow you to write in plain English at compile time and it'll use CoPilot to compile this to C# which doesn't work.
This is exactly the same story as c++. You’d think we’d learn from history.
Too many smart language people trying to justify their salary.
Have an example of overlapping syntax?
int Foo => 4;
private int Foo { get => 4; }
private int Foo { get { return 4; } }
https://sharplab.io/#v2:CYLg1APgAgTAjAWAFBQMwAJboMLoN7LpHoCW...
Yes, so you are right.
I don't get why in IL, the expression bodied member is different, though. Still, makes sense if you have learned C# starting from the most verbose form (3) then (2) was introduced, then (1).
E.g. you could add
private int Foo { get; } = 4;
To the above example given that the behaviour is identical, although the compiled output should be different so I didn't to avoid any nit pickers.
Miles ahead of the tooling, frameworks, and features of most languages.
>There is a reason that we write javascript in the browser
Yes, we're stuck with it.
>and operating systems in c or c++
Yes, the legacy.
>and telco services in erlang
Erlang doesn't have some particular stronghold in telco services. It was created by Ericsson for their own such use, but it's not like other/most telcos use Erlang. Ericsson itself even neglected (and for a period even banned new Erlang projects, preferring other languages).
>and academic works in python rather than in C# or F#
Huh? Who writes "academic works in Python"? I'm sure some do. Still many write Java, C#, and others, including C++ and even Haskell. Except if by "academic works" you meant "in machine learning and scientific computing", or "use as teaching language".
> Yes, the legacy.
That's hardly the only reason, and certainly not the reason why new OSes are not written in .net languages.
If we had more mature systems languages suitable for OS development sooner, people wouldn't use C and C++.
You're obviously not going to use it for low level or high performance system programming, or numeric stuff where you'd use Python, but for day to day getting stuff done it's amazing.
The Fable compiler for F# barely adds any cost on top of what TS adds in terms of dependencies, compilation and tooling and IMO gives you a much better language for developing applications. And you still get to use the JS ecosystem.
Most of the cost is related to familiarity with both F# and JS, node and the browser.
But once you match on a pipeline of Results you can never go back!
I've tried plenty of other to-JS compilers, even for languages that I love, and I still choose TypeScript every time.
It doesn’t feel that much different than the TS compilation process. It is not what you’re expecting.
Am I not contributing to the conversation? Has anyone else even mentioned F# or Fable?
I wish that instead of TypeScript, MS had just used F#.
It seems like they took some of the concepts of what can be done in F# and made TypeScript. I wish they had just stuck with F#.
It's almost like it was marketing, like they didn't like how F# was viewed so TypeScript was a re-branding.
Maybe it is because TypeScript can be considered a DSL that could be built by F#. Like Elmish.
EDIT> Yeah, not sure if enough people understand F#. You can easily build TypeScript from F#. Or maybe the downvotes are from Haskell people that just view, a functional language can build anything so it isn't worth commenting on.
We tried Haskell in the browser before and it was a huge mistake. We want back to TypeScript afterwards.
Haskell wouldn't work in this context.
I've had a very easy time debugging Fable compiled projects.
Again, I have extensive node and JS experience which is absolutely required for working on a Fable project.
I would argue that the hardest parts of TypeScript aren't that much less of a leap than F#.
I would argue that this code is easier to debug than the equivalent .tsx:
[<ReactComponent>]
let Counter() =
let (count, setCount) = React.useState(0)
Html.div [
Html.button [
prop.onClick (fun _ -> setCount(count + 1))
prop.text "Increment"
]
Html.button [
prop.onClick (fun _ -> setCount(count - 1))
prop.text "Decrement"
]
Html.h1 count
]
And this basically looks like JS to begin with: [<ReactComponent>]
let ShowGreeting(props: {| greeting : Greeting |}) =
React.fragment [
Html.h2 props.greeting.heading
Html.h4 props.greeting.subheading
Html.p props.greeting.content
]
app.get("/", fun req res next ->
promise {
let! response =
req
|> gql "query { greeting { heading subheading content } }" {||}
match response with
| Ok response ->
let greeting : Greeting = response?greeting
ShowGreeting ({| greeting = greeting |})
|> res.renderComponent
| Error message -> next()
}
)
Again, Result types! Computation expressions! Error handling with these constructs is well worth the price of admission.Compare this to the try/catch approach you'd be using in TS:
Besides,Isn't typescript developed by the same people who made C# and also takes quite few inspirations from it?
Google is the only company that is in a position to do anything about this and they gave up on Dart. So yeah, we're basically stuck with it.
This is not a universal thing. I wouldn't recommend these languages for every problem and there are lots of places where C# and others definitely makes a lot more sense (including, arguably, the problem domain in my last role). It's just what I like to work with and what is best suited to the work that I do and enjoy.
It seems like .NET is really geared toward business cases. But .NET is huge, so covers a lot, and not all great.
If you were doing something embedded, or specialized. Maybe that is thing.
On other hand. I also used to love .NET, but when I tried using Python, I did have to agree Python was really fast for simple cranking out little programs.
The OP and yourself must struggle with programming. shrug
"Everybody who doesn't share my language preferences must be bad at programming." Enlightened thinking there.
Biologists are all over R, physicists - Python, &c.
This is flawed logic and I assume people upvote it for visibility rather than genuine agreement.
.Net is the best at being .Net I guess. It has loads of libraries that are both good and terrible. I think the .Net web ecosystem is a god-awful mess of magic DSL's and configuration, and more and more sugar syntax is being added to C# to make it harder and harder to on-board new developers, and .Net Core deciding to break backwards compatibility is probably costing my org 10's of millions of dollars. But I guess I don't need to type as much as I did 10 years ago.