This reminds me of a few (<10) years back when a high school student needed some C programming assistance.
I then found out that they were being taught to use Borland Turbo C.
I suspect the case for this is similar: Some person who once upon a time learnt to program and then never practiced nor developed their skills somehow got a job teaching programming, and is now trying to apply the ancient tools they were taught somewhere around the time when some fish decided to walk on land because its all they know.
Borland C and Pascal were great for learning programming in mid-90s, because of one crucial feature: an immensely good built in help reference.
Whenever you wanted to know syntax of some command, you print this command, press ctrl-f1 and is presented with docs, complete with a working example. It was insanely great. Remember, stack overflow didn't exist then.
QuickBASIC works the same way. Rust doesn't really build its help documentation for "built-in" access in the programming environment (everything is web-based, even "local" docs launch in a web browser) but examples are a first-class feature; they're reused as test cases.
Even though the Rust docs aren't built for this purpose first, in IntelliJ or CLion I can still press Ctrl + Q on a method and see the full method documentation with examples. I think what IntelliJ does is simply parse the doc comment for that method and then render the markdown contained in it in the little popup. The standard docs are built from those comments as well.
Well, JavaDoc is a mix of HTML and custom tag language based, whereas Kotlin moved to Markdown + some similar tags. Because HTML is a pain in the rear to write compared to Markdown and can't express everything you want concisely.
Maybe you mean Rust's documentation is rendered to HTML. In which case, sure, but so what? Good docs can be rendered to non-HTML formats too, typically for IDEs to display quickly without needing to load a full browser.
With Go, the ability to instantly read docs for anything (even just pulling docs for a single function) in terminal is extremely helpful and far superior to a HTML-only approach. "go doc net/http.Client" pulls up the docs for the http client type.
It's one of the features I miss most as I code Rust, and the lack is very detrimental to the coding experience, as pulling up a browser is a massive context switch.
Well, it may be on everyone's machine (just type 'which emacs') but that hardly makes it the most commonly used IDE, which I think is what's hard to stomach.
Not long ago, there was support on Firefox to directly open HTML pages within compressed files (through the jar: protocol). If that still existed, it would be an option to distribute the rust HTML docs within a compressed .jar file, and let the browser read directly from it.
If the old harware aphorism is "Never trust a computer larger than you can lift", then the software counterpart to that must be "Never trust a compiler that doesn't fit on a single floppy". <g>
"Never trust a compiler that doesn't fit on a single floppy"
I'm coining that second expression right here on Hacker News, today, 1/22/2020!
I'm fairly certain no one has said it prior...
But if they have, then my humble apologies, and in such case I'm un-coining it... <g>
Stack Overflow has dumbed people down significantly because of the mental laziness it engenders.
In a time before the internet, it used to be that books, and occasionally magazines, were the initial entry points to understanding software, hardware and electronics. Then the BBS came along, these secret islands of knowledge and trade.
I learned Pascal and assembly on Turbo Pascal with trial-and-error and lots of context-sensitive help. These days, development is mostly fragmented and half-working. Progress is neither linear, increasing nor assured, and much is lost, reinvented not necessarily as well and lost again.
Also, eventually coding will
decline or bifurcate more because general AI will allow non-programmers to ask a machine to do Star Trek-like self-programming. Essentially all office jobs are vulnerable to elimination as mechanical machine operators.
Speaking as someone who learned in the Turbo Pascal / Turbo C era, StackOverflow has moved the state of the art on hugely, and people's dependency on it is more a symptom of the environements they are working in than anything else.
> Progress is neither linear, increasing nor assured, and much is lost, reinvented not necessarily as well and lost again.
The big difference is that we are now networked. The target MSDOS environment was not a moving target and had no security considerations. The world is very different now; we do so much programming in the browser because it's the one single cross-platform zero-friction environment we have. But those reasons also make it a battleground between platform monopolists.
There is also so much more software. Part of the problem that Stackoverflow solves is dealing with this. You can't be an expert on everything, there isn't enough time and it moves too fast. So you need a quick solution to incidental problems so you can get back to the "core" problem.
Interesting code and fairly readable; I liked the simple scripting system, and there were a few comments and examples, and yes - double buffering of the Mode 13h screen (though the memory allocation seemed weird, but maybe there was a good reason for that). Certainly better written code than what I was writing at 16, mainly in BASIC and assembler at the time (was a fan of the Lee Adams series of 3D programming books).
Affordable C compilers (for a teenager at least) were not really a thing at the time (IIRC, even the DOS stuff, if you owned such a machine which I did not, still cost a couple hundred dollars around 1989-90-ish). I didn't manage to get a C compiler until the mid-90s when I picked up a copy of Turbo C for DOS, but I still think I paid $100 for the privilege.
If you know another way I can deploy code instantly on everything from PCs to phones to televisions without even having to sign anything, pay anything, or get approval, I'm all ears.
Since the early days of my career, people keep predicting the demise of the programmer. I remember CASE tools, and then Microsoft with VB were signs of the end. Roll forward 30+ years in IT, and complexity keeps going up, and programmers are still needed.
Maybe I'm just old, but I'm probably going to retire, and AI is not going to replace any programmers.
From what I see, the quality of the software in Corporate America reassures me that programmers will have jobs for many decades to come.
I don’t really blame StackOverflow here. We are living in an age where there are exponentially more people attempting to program than their used to be, and with lots of different motivations. Many of those people just aren’t capable or interested in being experts. The problem as I see it isn’t that this situation exists, but that those workers still command such high salaries.
We aren’t nearly as close as you suggest do the level of code generation that would replace the bottom quarter of the labor pool even, but if that day ever comes I believe it will be really profitable for the top 20-30%.
One of the issues is people in general don't pay for dev tools anymore, and writing documentation is laborious. Borland could pay documentation authors to write extensive help and examples because they charged money, and sold a ton of licenses. Stack Overflow is simply crowd-sourcing the same thing.
'Eventually' is likely to be a very, very long time. I doubt we'll have self-programming systems like that even in my children's lifetime. It will likely take AGI to do it. There's the classic tale of programmers back in the 90s quiting their jobs because they thought Visual Basic would let non-technical bureaucrats write their own software, so there would be no need for specialist software engineers anymore.
One of the world's top self driving car engineers reckons we might never get Level 5.
I'm not an AI denier. Eventually we will get AGI, I think it's inevitable. It's just that the time horizon is so far off it's not really worth worrying about. We don't even have a clue how to go about designing it's general operational parameters or architecture yet.
> One of the world's top self driving car engineers reckons we might never get Level 5.
I have some minor-level experience with self-driving car software, algorithms, etc. The majority of this is from various MOOCs I have participated in over the years, as well as research papers, books, and other things I have read and consumed. In short, I am not an expert, but I am not unfamiliar with the technology, either.
I personally think we'll never see actual widespread usage of self-driving vehicles outside of a very few narrow and carefully controlled (and regulated) cases. At least, I suspect, within my lifetime (which honestly, I'll be lucky for another 30 years or so).
My reasoning is that people will only trust perfection when it comes to riding in a self-driving vehicle. They will only be willing to use one if they can be assured that it will Never Crash, or be crashed into. They have no problem driving a car themselves, or being surrounded by other people driving cars. They have no problem with those crashing and even killing people - maybe even themselves (though they tell themselves fairy tales of it-will-never-happen-to-me to soothe over the reality). But introduce a machine into the equation...
...and that machine has to be Perfect. It cannot make any mistakes. It must avoid issues and be Safe 100% of the time, no exceptions.
In other words, people want the impossible from a machine, but will give utmost allowances to themselves and others as "humans".
I think a lot of this has to do with assignment of blame. When they crash or are crashed into - there is someone to assign blame to; themselves, the other driver, etc. Someone they can yell at, figuratively or literally.
A self-driving car? No one to yell at. No one to assign blame. Nothing that will feel bad for its error or failure to avoid something.
People can't handle that. They don't want a self-driving vehicle that has a safety factor of say, "seven 9s" - it has to be 100% safe or nothing. Because even if it makes a mistake only once out of a million miles of driving, that is still not safe enough. They want the unobtainable - a perfect machine, a machine that will never fail. Nothing like that can or will ever exist (basic laws of thermodynamics prevent it, for one thing).
Even though they themselves, or even the most professional of professional drivers - can't even come close to approaching this level. It both madness, and understandable at the same time.
> My reasoning is that people will only trust perfection when it comes to riding in a self-driving vehicle.
From what I've seen I think your model of human behavior is flawed. Aircraft have been mostly fly-by-wire for decades and software flaws have led to some crashes (most recently those of the 737 Max), but that hasn't stopped people from flying in planes.
People have already been killed by self-driving cars, but that hasn't stopped the testing programs. Tesla automation (though far from full self-driving) has led to a number of fatal accidents yet people still buy Tesla's and I haven't heard of any public outcry to ban them from the roads.
I too am skeptical that we'll be seeing full self-driving cars anytime soon, but not for the reason you give.
I think the real issue is that AI-like technology has a 90-10 problem. It's relatively easy to get to 90% of human level performance but that last 10% is much much harder - unpredictably harder. Unfortunately self-driving cars are an area where 90% isn't good enough, even 99% isn't good enough. You probably need to get to something like 5 or 6 9's to be acceptable for broad general use and no AI-like technology has yet gotten anywhere close to that.
EDIT: I didn't mean to imply that the 737 Max is fly-by-wire, but the MCAS system that caused the crashes is a comparable technology.
The usual practice is for autopilots to be switched off when the plane is within 200 feet of the ground. (Or a similar distance.) I think a self driving car would be a much easier sell if it never came within 200 feet of anything it could hit.
The way I see it, we will have the manufacturers of the cars to take the blame and to ask for compensation. They will probably take out insurance for each car they sell to pay out any of these claims with the premium that depends on the accident rate, added to the price of the car. This would be better even if the accident rate is the same as the current human one. I think we would see self-driving cars of limited capability become commonplace in the near future because of the extra safety it offers us especially from blame if an accident does occur. Also, the complexity of developing self-driving systems is because we are trying to adapt them to current-day roads if we make changes to the roads by adding lanes, stationary sensors to help self-driving cars we could make accidents are very rare.
The stackoverflow just makes it easy to look up trivia. The internet in general makes it easy to look up answers to simple problems.
That leaves more time for the interesting problems. I think that makes programmers generally smarter than before. They start from a higher base and can climb more quickly.
Also, you’re overestimating the potential trajectory of current approaches to AI.
But StackOverflow helps only with basic to common intermediate problems. The most upvoted answers often resemble the most common beginner problems. So it indeed very much replaces the old paper/online help documentation, is often better written and more readily available. On the other hand for more difficult problems it's common to not get an answer. In fact the problem might be so specific that it's even against the SO rules.
> coding will decline or bifurcate more because general AI will allow non-programmers to ask a machine
I was expecting this development with the rise of React since at least the visualization part has become completely declarative. It's no rocket science to automatically transform that, in fact being an XML dialect there are a lot of tools available for this. But still, even in 2020 people still make money with writing HTML/CSS either plain or within a CMS.
In fact even a reverse development happened in some regard. In the 90s it was quite common for people to write CRUD apps running in Access, FoxPro etc. These tools - like Delphi which might be closest to that - practically disappeared.
The analytical load is still there and cannot be abstracted away. The decline of Access etc. happened because many aspects couldn't be mapped. Not to speak of all the nitty gritty details needed to make applications run safely and maintainable. There's still a very long road ahead to automatize all that, especially in a way that it consumes only a reasonable amount of CPU, memory and storage...
> Stack Overflow has dumbed people down significantly because of the mental laziness it engenders.
I don't think SO has dumbed down people. It's just the average level has tanked because of influx of people in tech. In 1980s average computer person was highly skilled, educated and intelligent, because even to get access to even the simplest computer required a solid dedication and investment. Now, tech is ubiquitous, easily accessible, and lots of people with most different backgrounds jump in. You'd be amazed how many 'developers' fail to solve FizzBuzz test. We actually DO test applicants with it, and results are extremely appalling. I am unable to understand how a person who calls himself a developer and has experience can fail this, but I have learned to accept this as an observed phenomenon.
I have been thinking the frustrations I am forming with writing software was due to an ever lowering barrier of entry. I never thought about mental laziness as a factor, but that explains the frustrations so much more clearly.
* The DOM is a 20 year old standard that is the primary interface to any markup language and the primary interface when working in the browser, yet it is still somehow an arcane mystery of lost knowledge - https://news.ycombinator.com/item?id=21069571
* Excessive sensitivity not found in other industries. I have heard that several psychologists are predicting my children's generation will be the most offensive generation as a counter to the extreme sensitivity (fragility) - https://news.ycombinator.com/item?id=20668380
* More selective bias, online code tests. Now when I see online code tests without extremely specific grading criteria I instantly terminate the conversation. - https://news.ycombinator.com/item?id=20605329
Sure... when general AI becomes available, flexible, and has solid usability for something like this. Which will be about the time that faster than light stardrives become common and our meals are materialized out of thin air on demand.
Despite perceptions, the last few years' "AI boom" is mostly marketing. Advances in processor power have made deep learning algorithms practical outside lab settings, but we're not even close to a "generic AI" that can think as well as even a dog can. That's decades away at the earliest.
Right now, we don't even understand how our own brains work.
I would argue that StackOverflow itself is not a problem—it is instead the laziness of many in the "newer" generations of programmers.
StackOverflow has many great explanations, which are no different than reading a chapter in a book (it's just a book that is extremely relevant to you problem).
The problem is that lazy people demand code dumps, and lazy people provide code dumps instead of explanations. This then becomes a feedback loop as people get used to this degree of laziness.
This is especially rampant for Web topics, and to some extend also a counter-argument to the Borland help pages with examples: When presented with a fully written solution, people will blindly copy it and only do the minimum amount of work to make it run.
I think this is accurate. I'm pretty technical but with no formal education on programming. Currently I can only tinker with programming in my free time. There are a lot of huge gaps in my knowledge and it sucks sometimes, but at least Stack Overflow allows me to solve certain problems more easily, so I can get on with doing fun stuff.
Regardless of trade, I never approve of this mentality as the "shit" rarely gets done responsibly or sufficiently, as that cannot be done without fully understanding at least the chosen implementation.
Perfectionism is not required, and can get in the way of professionalism. This is about a minimum amount of responsibility.
The mistake is assuming Delphi is bad and stupid. Delphi is MUCH better than C and C++.
Miles ahead.
Pascal is what we need, but C is what we deserve. Billons of dollars wasted in it.
What it have bad is the massive mismanagement of the owners, and that translate to lack the influx of talent to it.
Note: I'm moderator in a Delphi forum and use it for years. I'm now in rust, and is great yet:
- Some of the problems that rust fix? Delphi too decades ago.
- Delphi still compile so fast. All the stupid c-based langs are turtles. Including LLVM. Is a sad joke that "I use C-/C++/rust" for performance and the compilers NOT PERFORM. Period.
- All the other currents langs on earth, all of them, still fail at build a GUI easily.
- Only recently, with Go and now rust, people rediscover the joy of easy deployment. Delphi have it decades ago.
Of curse Delphi is not perfect, and we the users know it. Sadly, in this industry worse is better and without a path to improve the lang you are at mercy of the owners. But like smalltalk, foxpro, hypercard and others, Delphi is a testament of what could be a decent lang/environment.
That the community at large still inflect itself with massive amounts of pain and billons of wasted effort with c/c++/js and still refuse to learn? Is something I will never understand.
P.D.2: If this sound like a rant? Yes. My super-duper machine is still compiling with rust and I'm frustrated, because this post remind me that this pain could be avoided...
The problem I had with Delphi was Embarcardero's pricing. At the time I was looking into it there was no express license or anything similar so it would've been a few hundred dollars to just try and learn. Contrast that with Visual Studio Express which was free and allowed me to learn C#. There was a significant cost to learning Delphi. Since then, however, I discovered Free Pascal and its ability to support multiple platforms and targets. Granted, I abandoned my journey of learning Object Pascal a long time ago.
I fondly remember using Delphi to create native Windows GUIs. It was really great for this.
The reason I stopped using it was that I discovered that there are many more program types than Windows GUIs - and there, C++ (or sometimes C) is really the best. High performance lock-free lists? Support for obscure network protocols? Containers with custom allocators? Delphi does not really work there.
Is interesting to note that you can see "High performance lock-free lists" in many langs, but near none have good GUIs builders. Good GUIs builders are harder, and your "High performance lock-free lists" is easy, also you can use C/C++ libraries in Delphi too...
And with Delphi the language and ecosystem are almost synonymous. Sadly. Is the compiler was free from the start and the IDE would cost money, they might have had a much stronger offering.
What's the problem with it? Programming snob? Isn't it still C programming after all? I don't understand the problem with people bashing Borland after all these years! Didn't you know that the accomplished Mr Anders Hejlsberg was behind Borland (TurboPascal and Delphi), before he was appointed to develop Microsoft C# and Typescript? So, what's the/your problem!?
I'm thinking of a graduate turning up for a modern programming position and opining:
> I know Delphi!
I would argue you can made good courses in any language and it would seem more convenient to teach in something that has better transferrability into industry.
Also the response is likely aggravated by this quote from the source article:
> a curriculum that has taken heavy damage from the adoption of Java and C# in the early 2K’s.
May be one problem might be that it might condition learners to the peculiarities of programming for DOS and its archaic memory model, which aren't that of relevance to modern systems.
Turbo C was a great C compiler. Embarcadero still gives away two (!) free versions of its C/C++ compilers today: the command line tools, and the entire IDE and toolchain in its Community edition.
Depends on what sort of stuff they learned - remember that those students knew nothing about C so they'd be learning very simple stuff.
As an example, the free version of Turbo C++ 1.01 that is available through the Borland/Embarcadero museum (or was at some point, i don't know if still is) has ~34 introduction examples (referenced via their guide) that outside of a couple, use only basic stdio and stdlib stuff (these 2-3 examples that use a non-standard header use conio.h which AFAIK is borland specific, though Watcom/OpenWatcom and Visual C++ also seem to provide the used functions) without any DOS-specific functionality (be it far pointers or whatever) and could compile with any modern compiler.
I see your point, but the rationale might be completely different. Most programmers nowadays focus on web programming. The main reasons for this are partly technical (easy deployment, easier upgrades, multi-platform) and partly political (subscription model, complete control of user data).
Now, a minority of us believe that desktop apps are really worth fighting for. They are fast, they give user control over their data, they can work offline, and the subscription model is optional rather than built in. Some in the mainstream would like this to be killed. Some companies like Apple approve it as long as they get their cut. But most simply don't care. If you don't want a future where everything you use is controlled by someone else, then the Turkish decision is not meaningless.
You missed the point: Borland Turbo C was a proprietary compiler and IDE that had its last release in 1988 (replaced by Borland Turbo C++, which died sometime in the 90's). It has no relevance in this day and age.
If you teach C, at least teach C99 using a contemporary compiler—C11 was available when this all occurred. At no point did I suggest that a different language or paradigm should have been taught.
Had I been that minister, I would absolutely do something similar to what Turkey did.
If the goal is to get more students to become programming literate, then the last thing that I would want is to pick a random flavor of the day language, with some frameworks, and some "best practices" debated to the oblivion on HN or Reddit. I would want all schools have a pretty standard system, with identical software that works identically because the goal of that software is to act as a pen and paper in a class. It needs to get out of the way.
Imagine the conversation had they picked C++ and do Linux. First, there's going to be a multi-year debate if we should be using Ubunto, Centos, Arch, until some pointy headed expert says "The future is in CoreOS!" just before everyone decides to standardize on Fedora. After that there would be a fight about versions, because everyone knows we should always run the latest. That's except for the group of people over there, that are refusing to run the latest and want to run the proven. Oh and they do not want to do C++, they hate C++ and say it should be Rust and since it is a Linux system and shadow IT is pretty easy on it, they are going to teach Rust! Or mostly argue about teaching Rust... etc... etc.. etc.
Here's a thing - if 10% of students gets out of the Delphi environment and starts messing with GCC for any reason then the program already succeeded in achieving the goal.
> and is now trying to apply the ancient tools they were taught somewhere around the time when some fish decided to walk on land because its all they know.
A little bit too harsh. As the article points out Delphi is currently #12 on the TIOBE Index [0]. Above Go for example.
Absolutely too harsh. Remember Pascal was designed to be a learning and teaching language - this purpose is what it was made for.
And Delphi itself was a standout leader in technology, a huge inspiration for C#, and still a key technology used by many people today. It's just not well known. Not well known != ancient.
As I recall, c# was developed by one of the primary designers of object pascal, Anders Jejlsberg, after being poached away by Microsoft. (https://en.wikipedia.org/wiki/Anders_Hejlsberg)
and think that they actually didn't get a job at teaching programming but they involved in politics and appointed as "Minister of Technology" for their "loyalty" to the Head of State. That's what Turkey is dealing with right now.
5 or 6 years ago, our ex-minister, claimed that it is dangerous to work with computers since they can be challenging for the mind in a conference about cloud computing. Let that sink in.
I wouldn't call Delphi ancient. It's not like they haven't been updating it. Delphi can target Windows, macOS, Android, iOS, and Linux. It's pretty good:
On the positive side, Turbo C didn't include telemetry and didn't have to download "plugins" from the internet.
Delphi is a modern development environment. I haven't used it recently, but it was incredible in the 90s/00s and I know it kept adding features and platforms. AFAIK Beyond Compare is built with Delphi.
You missed one important point about Turbo C: The debugger. It has an amazing UI even at today's standard. If you need an all-in-one tool to teach programming (esp focus on the concepts), Turbo C is still a good choice.
I wonder if anyone has come up with a TurboC-like UI "theme" for, e.g. Emacs. Freepascal uses a Turbo-like UI by default and a free reimplementation known as RHIDE is already (IIRC) part of the FreeDOS distribution, so recreating the UI itself shouldn't be too hard. It might be a fun way to boost adoption of these terminal-based tools, since the ergonomics and UX is in fact quite reminiscent of modern IDE's.
That's a nice start, but it lacks some of the most distinctive features. Even being limited to a single full-view buffer is not very Turbo-like. And I'm not seeing much IDE-like integration.
I remember back then(2002'ish), Pretty much all CS labs had Borland Turbo C.
The funny thing was the output prompt would disappear after printing things, so to hold it there, people would add getch(). This was so common, I remember at one point people treated getch() was something you always added at the end of the main(), like a return statement.
What does it matter which programming language they learn in high school? It's not supposed to be the language you use for work. It's supposed to teach you to program.
If anything it should be mandatory to learn something else. It might be the only non-work programming language they will ever learn. Cradle to grave Python / Java?
Would Common Lisp / Haskell be considered a bad / good / ancient choice?
The student has to learn programming skills that can teach them the fundamentals quickly, ideally be transferable to most fields and hopefully something they can use freely on their own time.
Python is great for this. You can have kids building whatever in class and they can go home and use the same tools and make videogames or visual novels or whatever else strikes their fancy, and when they get hired still use the same tools.
My main issue with haskell is that it's likely not very transferable. That isn't to say you shouldn't be able to use it or teach it - maybe you can teach something unique with it you can't teach with other languages, but that needs a bit of explanation beyond just "well I prefer it".
The education should serve the students, not tickle the fancy of the teacher.
> My main issue with haskell is that it's likely not very transferable.
I thought this for a long time, having taught myself Haskell in university. I never regretted it, but I'll admit I never thought of it as a practical choice either.
Then I ran into Rust, and found I was somewhat mistaken. ;-)
technically it does not matter. The trouble is students HATE learning something they think is a waste of time. I've found it impossible to convince them that the first language doesn't matter.
If they just learned anything they'd progress at roughly the same rate, but when their motivation is impacted it makes a bigger difference.
I have fond memories of learning Common Lisp in university. They might be fond only because it's something I decided myself, but SLIME was a revelation. However...
Common Lisp lacks a static type checker, or any decent type system. These days I consider that a catastrophically bad design choice, and I can't justify teaching it as anyone's first language. It's also, well, it's design by committee.
Scheme might be better -- at least then you'd be learning about call/cc. If you aren't learning a language purely for work, then I think learning it should teach you something new. Scheme, Rust, Haskell, even Java/Kotlin if you've never used a decent IDE -- all of those can teach you something. CL sort of can't, anymore, though for a long time it could.
Or someone marketed the software to Turkey as a great way to increase their IT skill set as a country. Borland was awesome back in the day (at least in my opinion) but what Embarcadero has done with the software in years recent is a travesty. If they're going to insist on Pascal they should go with Lazarus.
I've been toying with the idea of running a few classes to help early and mid-career adults learn to program. Although it's been so long since I first learned that I worry I'd struggle to get the basics across.
Does anyone have a recommendation for a good, up to date, open source, introduction to programming? Ideally something that uses an experienced programmer (i.e. me) to guide.
My kids never showed much interest in program despite my encouragement, but this year our high school changed its programming curriculum to follow Harvard's CS50 model:
The first half of the course is mostly in C and then switches to Python, and I really think it is a very well designed course that get students doing some interesting stuff very quickly while building a solid foundation for future learning. There is an online version of the course and students can watch all of the videos and lectures. I believe there is also a teacher training program for the curriculum.
I was surprised when my son came home and started asking me questions about malloc and free, but he has learned a lot in a very short period of time.
In my experience, it's close to impossible (or maybe even totally impossible) to get the basics across. I have been trying with many non-programmers for years and I have followed many people who tried to become programmers.
At this point I think it's probably a matter of "you either have it, or you don't". All of the people who succeeded "already knew" how to program, before I even showed them, or they never managed to learn.
And my experience is even with people who actually did manage to secure a programming job. In my opinion they still don't know the basics - they blindly follow "procedures" and mostly do copy/paste programming, without being able to grok the idea and why these things work the way they do..
The truth is what many of us consider to be basics - big O notation, b-trees, so on are not really needed by the average programmer. They might be useful (I get use from them) but they're not necessary.
Likewise, getting into intimate discussions on file encoding or strings in memory just isn't going to be retained by someone whose major interaction with a computer is facebook.
Focus on practical tasks, but take time to explain what code is doing in plain english. If you've done rubber duck debugging, you're aiming for that level of simplicity in your explanation. Avoid technical words, use simple metaphors and generally avoid the history lessons. Once you establish a baseline of skill in the developing programmer, swap the roles - have them explain their code to you.
I'm not even talking about big O or algorithms & data structures.
I'm talking about the basic concepts of function, iteration, abstraction, indirection etc.
Yeah those are definitely things that new programmers need to learn, but they usually need to learn them by doing things the hard way a few times first.
"yeah, that's a lot of copy and pasting isn't it? Want a neat trick to save yourself some effort?"
I have as well, I'm happy to report out of the last 5 non-programmers or very-new programmers I've trained, 3 are senior engineers and 2 are on-level engineers and I'd gladly work with any of them.
I like the "X by Example" books from O'Reilly in whatever your desired language is. Not exactly open source but quick to learn practical programming which is probably what you're after with adults.
Sure you can learn a lot but I have no idea why you would choose Turbo C in 2020 over say a Raspberry Pi with GCC. Turbo C (discontinued in 1990) is going to expose a bunch of irrelevant things today, as even most microcontrollers are 32-bit:
painful 16-bit near/far memory model
a single task operating system (DOS) that has been long obsolete
In going from zero to programmer those aren't bad things, they are a simplified learning model.
Would you advocate pilots stop learning to fly in single engine prop planes and instead jump right into the cockpit of an Airbus because that's what they will encounter in the workforce?
Any why are doctors practicing on dead people when clearly they can't possibly help them or cure anything that way...
A 16-bit space is not at all simplified, it's far more complex. Because of that, it is a terrible choice. It's a much more difficult memory model to learn in. In a flat 32-bit address space, a pointer is a pointer and it just works. It's much easier to conceptualize and learn on. Have you ever programmed for a bank switched memory computer? It's a nightmare. It's extra mental gymnastics pushed on the developer that have been irrelevant for a long time.
I don't think your example is a valid comparison. It's more like do you think all teenagers need to learn to drive a horse driven carriage before they learn on a modern car?
It does though, if you mix near and far pointers, you are going to be getting crashes. Pointer equality and comparison are non-trivial. Whereas on a modern 32-bit CPU you don't have any such distinction.
A classic, time-tested pedagogical approach that makes it easy for a student to reason about what the hardware is doing to execute their code... or a flavour-of-the-month JS “framework” that is impossible to reason about and really will be obsolete before the end of term? Hmm tricky.
Isn't this a bit like saying the last release of Ford's Model T was back in the 1930's? It is now called C++ Builder, and it is still regularly released. https://www.embarcadero.com/products/cbuilder
Yes, if when arghwhat said Borland Turbo C to describe a product without Borland, Turbo, or C in its name that product might indeed have a different release date :)
Totally agree. I've been making the same argument elsewhere on this thread. People are disagreeing with saying things were simpler back then. I don't know how anyone can have fond memories of a 16-bit CPU with segments or bank switching compared to a modern flat model and think it was simpler.
> I don't know how anyone can have fond memories of a 16-bit CPU with segments or bank switching compared to a modern flat model and think it was simpler.
"Fond memories" is easy to explain if that's what you grew up with. As for simpler, let me play devil's advocate for a bit: our "modern flat model" looks simple until you find out it's not really "flat". The 8086 model is basically "(segment << 4) + offset", while the "modern flat model" is actually a multi-level table lookup.
Yeah I guess that explains the fond memories part.
Some 32-bit parts are totally flat. Like low-end ARM parts with SRAM and no MMU. Compare that to a 8-bit or 16-bit PIC microcontroller where you need to bank switch to have a usable amount of memory for your application and its heaven.
But yeah, I see what you are saying. Still, pulling the wool over someone's eyes doesn't seem so bad to me about virtual->physical memory and TLBs as it does making them jump through a distinction between pointer types, but maybe I am in the minority on that.
I had to giggle recently when I heard "Delphi is dead". It's not. And I don't think it ever will, because, both as a language and work environment, it is quite powerful.
It has pretty low entry barriers, and is pretty capable. When I used it (as a hobbiest, during Delphi 5 and Delphi 7 times), it had a superb tooling, and a really efficient compiler. Everything "just worked". It's now 15 - 20 years ago, when we created really tiny Windows exe files. A notepad.exe clone in only 23kb size - with no external dependencies at all, just using pure Windows32 API and Delphi. These where truely fun times.
Totally agreed. I was fortunate enough to start real programming with Delphi 5 (and then 7). Nowadays I know dozens of languages and frameworks but nothing comes close to the experience of quickly prototyping apps that at the end looked good, didn't need any dependencies and were super-small.
Another benefit was that it was possible to interoperate with low-level Win32 API and the enormous component library provided by third-party authors.
> Another benefit was that it was possible to interoperate with low-level Win32 API and the enormous component library provided by third-party authors.
Yes, absolutely. I'm happy to see that "Project JEDI" is still around[1].
I use Delphi on a daily basis to code internally-used marketing automation tools. There is nothing that comes remotely close to it in terms of ease of debugging and overall productivity. There are better languages/tools to use for public-facing products, but for "I just need it to run" type projects, it works flawlessly.
For the commercial versions, AFAIK overall it's less than Visual Studio, but when amortized over a couple of years. Slightly different pricing model so trickier to compare.
The community edition is relatively new. Before that, there was some watered down version for $199 (if I'm remembering correctly). Back when I looked into it there was no way I could afford or justify spending that kind of money on a language that I may not even like or want to continue learning.
That's not how I remember it. An empty statically linked VCL GUI application used to weigh about 700 KB. Just as stupid edgy kids usually do, we were looking at other "C++ applications" a dozen KBs in size and were ranting about Delphi being so bloated and terrible. Of course, it was due to them being built on top of pure Win32 API, or being dynamically linked to a similar "bloated" runtime.
It's not like we had an internet connection to learn from.
At least that's how I learned the difference between static and dynamic linking.
Depends on the Delphi version. Delphi 2 (what i used and still use sometimes) creates a VCL app at around 200KB. Later versions added a bit, but i think it wasn't until after Delphi 7 that sizes ballooned.
However i have a feeling that MrGilbert refers to using the Windows API directly without VCL in which case you can create very small executables.
Yes, exactly - sorry I didn't clarify. There were folks out there who created stripped down versions of Systems32 classes, so you had a basic skeleton running.
Maybe I should write a progam like that, just for the fun of it. It still works nowadays. I might even get away with FreePascal. I'll give it a try. :)
Yeah it should work. A few years ago i reimplemented in Free Pascal most of the OWL 1.0 API that shipped with Turbo Pascal for Windows and you can create some very small executables with it:
(that 82KB executable uses almost all of the API's functionality, including type registration, dynamic instantiation and object streaming)
Though i never did anything with it, i mainly wrote it for fun. The OWL 1.0 API isn't really that better than using raw Win32 :-P. But perhaps now that Free Pascal added support for Win16 in the trunk i could port it there.
Grammar note: "hobbyist". "-ist" is the suffix for, "A person who does this thing"; "-est" is the suffix for changing an adjective into a superlative: "Yours is hobby, his is hobbier, mine is the hobbiest."
I really don't want to sound cynical about this great initiative(!) but it saddens me that among many open modern languages and tools, they instead opted for Delphi.
I cannot think of a single positive reason behind this decision in 2020. All I can think of is that the people that came to this conclusion are the ones who graduated from Computer Science related studies in ~1998-2004~ and immediately got themselves in politics. I lost count of how many times have I heard that if you pay for it, it's just better...
Finally, I admit that I'm definitely highly biassed when it comes to Turkish Politics.
All modern tools are really complicated compared to Delphi. I remember Delphi was so intuitive to design GUI and program its events so i could start making my own programs right after professor showed me how to make a button and handle onClick event.
Lazarus is pretty much a free and open source Delphi (yes there are differences but they do not matter much) and really not any different in terms of difficulty compared to it.
(if the time stamp doesn't work, skip to 11:32, the previous ~11 minutes are me downloading, compiling it and configuring it - not 100% necessary on Linux and on Windows i never do that as the installer is a classic wizard-based one, but as i write on the video, i prefer to compile it when using it on Linux - also note that on Windows you do not need to install FPC as it comes bundled with Lazarus, it is really just running the installer, double clicking the desktop icon and you're ready)
Positive reasons:
1) It runs out of the box without and Internet ocnnection.
2) The IDE is extremely good.
3) It teaches OOP and memory management (something often forgotten by today's programmers).
4) It is capable of giving very low level access to the host machine (like C).
5) You can even use (and teach) tricky things like pointers.
Last time i checked recent versions of Delphi have DRM that need internet connection. I even remember someone from the official newsgroups saying that he had to install a crack so that they can use it on foot in their laptop when they had no internet connection.
TBH, I found the low-level pointer stuff to be inaccessible. There is so much magic going on behind the scenes, and on the other hand it's hard to do pointer value arithmetic as well as pointer type arithmetic (you need to create aliases to no end). C is much more convenient for dealing with pointers, and it makes it much more obvious what happens from reading the code.
In Delphi culture, people say PChar instead of char* , and make tons of PFoo and PPFoo. And I think the reason is that some syntactical restrictions made Pascal easier to implement back in its time (last I checked there were still significant restrictions in Delphi)
Is it that Pascal is simply popular as a teaching language in Turkey? A bit of googling shows lots of universities offering programming courses in Pascal, e.g. [1]. It is a good pedagogical language after all.
The only reasonable alternative is Qt, but C++ is more complicated than Pascal.
Assuming they would want to try their hand at making money out of what they learn, they could target the kind of companies which were served by VB6 or FoxPro in the past :)
Anything web-based is ridiculously complicated and has worse performance.
Well why not? I've used Delphi for years and also Java/JavaFX/Swing. There's not much reason to use Delphi anymore when Java IDEs can do the same things, and much more, and with docs that are just as good or better, all for free.
In Delphi I do desktop applications that perform real time low level device control, talk over USB and some specialized radio gizmos, DirectX graphics and multimedia processing, real time data presentation, bulk data processing, game like communications over UDP etc. etc. All at the same time from a different threads. Good luck doing it in Java. I did try doing low level stuff with it per client request and it felt like masochism. Java was created with the different things in mind.
The only thing that you seem to be right about is the low level device control stuff. Everything else is pretty much already easy enough to do in Java. The language was designed with multithreading in mind.
"...multithreading in mind..." - Easy and efficiency are 2 different things. Java synchronization primitives and it's ability to flip bits incur heavy performance penalty when compared to native ones. You might not care about it but I do.
You are also free to point me to a good DirectX framework in Java and/or the one that let's you write Directshow and Media Foundation filters and graphs as well.
Besides your logic reads like this: since language A does the same as language B and you happen to like language A then nobody needs B. Sorry but it works both ways.
When I was doing enterprise stuff Java provided more value to me in that particular situation. Windows desktop: sorry I'll choose Delphi any time.
Java synchronization primitives and it's ability to flip bits incur heavy performance penalty when compared to native ones
I think your knowledge on this might be a bit out of date. If you look at the Unsafe class (in old versions of Java) or the VarHandle class in newer versions, you can implement synchronisation and bit flipping with the same efficiency as Delphi, indeed it compiles down to optimal machine code.
You are also free to point me to a good DirectX framework in Java and/or the one that let's you write Directshow and Media Foundation filters and graphs as well.
Well, you can do this, albeit nobody really does because Java code tries culturally to be cross platform so using DirectX would be an odd thing for it to do. There are COM frameworks that let you write COM objects in Java. Whether you can do high performance image processing does depend on whether the JITC auto-vectorises though, at least until the vector API ships.
But you can for instance instantiate a JavaFX video player and then apply hw accelerated effects to it. Writing your own image filters would these days be best done in shader languages or lots of AVX anyway, so neither Delphi nor Java would really be appropriate for that.
Windows desktop: sorry I'll choose Delphi any time.
Yes, if you want to specifically write a Windows-only desktop app (that isn't WPF/WinUI/the new stuff I guess) and use lots of Win32 specific APIs, then Delphi is going to be better at that. On this we fully agree.
Still, these days people mostly want to write for at least Windows and macOS if not also Linux. And then you can write a good desktop app with JavaFX and the java packager tool (with native installers and the general appearance of a themed Windows app).
FWIW I used Delphi for years in the 1990s, even wrote a 3D video game with it in OpenGL. I've also written cross platform desktop apps with Java/JavaFX. So I have a lot of experience of both to compare them against. Delphi was fantastic at the time, and I still sometimes point out to people how the web platform fails to compare to even Delphi 2 + Windows 95 in many ways. I don't think we're really so far apart. But times have changed and Delphi wins only if you compare it to the web.
> Windows desktop: sorry I'll choose Delphi any time.
Let me quote you then.
> Besides your logic reads like this: since language A does the same as language B and you happen to like language A then nobody needs B. Sorry but it works both ways.
There are perfectly good enough tools for the Windows Desktop already and they are available directly from Microsoft.
Visual C is not such a good tool to write desktop application. .NET monstrocities with almost the same problems in regards to low level stuff, multimedia etc as Java when I can have single exe with no dependencies? Thanks but no thanks.
Also I do not really appreciate mentoring. Was doing just fine completely on my own for the last 20 years.
When I was in undergrad taking Data Structures and Algorithms, the course was in C (or C++, I don't remember). But by that time I had already started programming GUIs in Windows (MFC days). It was actually really nice to wire up the base classes and operations for a data structure (push/pop/etc...) and then be able to see the operations working with a GUI. At the time, it was really cool to be able to click a "pop" button and see the head of a queue get removed.
It was even better to visually see various sort algorithms in motion.
So, really, I could see the appeal for that kind of teaching... but I still don't understand using Delphi/Pascal.
(Our first CS class was actually taught with Pascal and that was painful)
I agree the impact of writing code and seeing something onscreen is very important.
> I had already started programming GUIs in Windows (MFC days)
MFC and Delphi's UI model are completely incomparable. One is statically built, often in code, inflexible, hard to iterate, hard to use custom controls... and one is modern OO, buildable visually (streamed to text, so editable in text), incredibly flexible, very fast to modify, and with thousands of custom controls.
And these days it builds for macOS, mobile (iOS and Android), and Linux too. So it's a decent choice.
Well. If they went for a free, open solution, someone would say they went for the "cheap" option. Buying a million of commercial licenses sounds like a big investment, it sounds like someone cares.
Could just be most of Turkey's software i sin Delphi, or they plan on it being delphi. How much of other nations are similar with cobol etc? Except that no one is teaching it.
Define modern please. There is not a single thing about ObjectPascal language that relegates it as non-modern. Lack of new jobs - sure but that is a bit different subject.
How so? You mean that you can actually buy it and have permanent license instead of money being sucked from your account every month? Or get Lazarus for free and forget about pauing at all.
I mean, one may assume incompetence and corruption. And perhaps that's the case.
But on the other hand, teaching languages are not the same as production languages. There are a number of languages that may be more powerful, but I think Delphi is a decent choice for teaching.
* You want to teach principles. Delphi allows you to teach OOP principles. You may or may not agree that OOP should be the starting paradigm, but that is at least a popular and conventional opinion.
* You don't want complexity. I am sure there are many alternatives that do things better. Heck, I am sure some Haskell guy will tell us itt how he can build a graphical interface in half a line of code. But remember these are kids who may not even understand what a program even is!
* You want results. In particular, it should be easy to create things like a user interface via the IDE. The fun about learning programming is to create something cool. Kids today most often use UI's and not terminals, and I think there is real value to allowing them to create something they might actually use. If you struggle through understanding your first program, and all it does is to print out "Hello World" on a black interface, it is somewhat underwhelming.
But if you can use the IDE to create your custom "hello world" box with pink borders and a unicorn picture - well that's cool!
* Of course you want students to be able to transfer their skills to other languages. But that's arguably not a big issue with Pascal.
* Finally, you want it all in one package. If you have to learn a vast module infrastructure, it just complicates things. Here is your "language", you can do everything in it.
I remember when we were learning, we started to try to build games and stuff. We used the tools available to use, because it was all very complex and we understood little. It was useful to have such a limited toolbox in the view of complexity. I think if we were forced to think about modules and many, many options to do a thing, we'd probably give up. Of course it is educational to try to come up with a solution with a limited set of tools!
From this perspective, Delphi is not a bad choice. Indeed I think the only other similar choice would be C#, which would probably cost more.
I don't think the motivation is teaching-related at all. For teaching there are way better languages than Object Pascal, which is kind of outdated and has a lot of anachronisms.
However, Delphi is an outstanding tool for production and together with Freepascal/Lazarus one of the best options for cross-platform application development - certainly on a par with C++/Qt. So this is a pretty smart move of Turkey to get some innovation going, and I expect great new end-user applications to come from Turkey during the next 10 years.
It's not garbage collected, but also, not completely manually memory managed either. I can't quite recall how it works but it's mostly some sort of ref counting + some manual.
When teaching, non-GCd languages just get in the way. You don't want students apps to be segfaulting constantly because they're running into memory errors whilst you're trying to teach them something else. Learn programming and get confident with it first, THEN learn the techniques needed to safely manage memory (maybe).
I actually learned programming as a kid with first Turbo Pascal then Delphi. My programs crashed with the dreaded access violation error all the time. Debugging that sucked. I assume it's better these days.
It is manually memory managed, but that is only for objects you create explicitly or memory you allocate explicitly. Other types that deal with dynamic memory, like dynamic arrays and strings are reference counted.
But i still do not see why this is an anachronism. Do you consider manual memory management an anachronism?
>>My programs crashed with the dreaded access violation >>error all the time. Debugging that sucked. I assume >>it's better these days.
How would automatic garbage collection help in a scenario where you are deliberately accessing an object that you haven't created or have destroyed already?
Hm, have you used a GCd type safe language before? This is a bit of an odd question. In modern languages like Java (but unlike Delphi) you can't access an uncreated object or manually destroy objects, outside of special cases like file handles.
My point is that there's a lot to learn when you start out programming. Most developers don't write manually memory managed code anymore so it's a skill that can be pushed far down the list of things to learn, and trying to learn it right at the start will just get in the way.
You may love or hate js but it makes great language to start with, runs in your browser and has infinite labyrinths of complexity in every direction - perfect for students to play with. Why nobody is using it to teach?
Because it's a nightmare with ridiculous missing hunks, like the fact that you can't put anything but primitive types in a Set usefully. Why would you use it to teach?
Yes, I'd have lesson explaining it's behavior, how it works any why it works this way and maybe assign homework to extend it to support uniqueness based on structural equality.
You can't extend it to support uniqueness based on structural equality, because the Set type uses == to test, and there is no means in the language of overriding that.
You can extend it, trivial one would be by subclassing and overriding methods to iterate over all entries doing deep-equal. Better complexity can be achieved by hashing (doesn't need to be collision free) and scanning subsets per hash etc.
Professional programmers scoff at "old" languages like this, but they forget what it's like to not know the first thing about programming, or what GCC is, or how it's different from Clang, or if you need to install Linux to use it, or if you're making a huge mistake by using C++ instead of Rust, or if maybe Go is better, or why that one person said something about GraphQL, or if you need to install a virtual env for your python.
Delphi just installs with a double-click and you can write code in a box and it runs.
> Professional programmers scoff at "old" languages like this
Old languages? Delphi is a lot newer than C. C in a mostly modern form dates from about 1977; Delphi is from 1995.
If you want to just write code in a box and have it run, maybe you should use http://sketchpad.cc/ or https://jsfiddle.net/. Or code.labstack.com, intervue.io, codepad, codiva.io, paiza.io, compilr, ideone, onlinegdb, repl.it, rextester, mycompiler, jsbin, sequential, or the other couple dozen alternatives in https://en.wikipedia.org/wiki/Comparison_of_online_source_co.... Or ObservableHQ, which is fucking amazing. Or try.jupyter.org. Or just your browser's JavaScript console. Or ShaderToy, where you can program in GLSL. Or Philip Guo's http://PythonTutor.com/ which can step you through the execution of simple code step by step while visualizing the stack.
And Python is five years older than Delphi, too. So it's not about disdain for old languages. Python was originally developed to be easily accessible for beginners, based on Guido's experience with ABC, which was purely a teaching language, and for some time Guido's main project was CP4E, Computer Programming for Everyone. It's moved away from that in the last 15 years or so, sadly, but some aspects of it still remain.
Or you could use Delphi, install once, deploy on any platform you want, keep your sanity and you not have to worry about anything, including WTF codiva, sequential or leftpad.js are.
I love the fact that you completely ignore that a large percentage of people do not have internet access, and even if they do it can be very slow.
Just because Delphi isn't cool doesn't mean it's not useful. It can teach many concepts that students can build on if they desire to.
Heck, you're acting like the first language you learn is even important. I learnt using Visual Basic 6 and it's not like I didn't go and learn new languages by myself.
>Delphi just installs with a double-click and you can write code in a box and it runs.
You can do that at https://www.onlinegdb.com/online_c_compiler, but do programmers use that website for professional programming? No, because professional programming is about integration into a system/platform, not about one-size-fits-all sandboxed environments.
I use C++/C, Delphi, JS, Python. Also Java, C#, PHP and bunch of other but on and off basis. Here is my opinion
As a language Delphi/ObjectPascal is anything but ancient. It is kept up to date and has all the important features one would expect modern language to have sans garbage collection (well I actually consider this as advantage).
It produces fast native executables without any dependencies. It compiles with such speed that one can write shell scripts in it. It has the right balance between a mountain of complex features C++ has and something like Go. Its IDE is nice as well and full featured. Both language and the IDE exist in paid version supported by commercial vendor and as an opensource project in case of Lazarus/FreePascal. Sure there are some problems but show me the language that does not have any,
In my opinion the only REAL problems with the language/tools are all political. At some point these products were suffering from bad corporate governance and on top of that Microsoft went out of its way to actively destroy market for these in North America and along the way poached all leading developers from Borland including main language architect.
To make a conclusion I think that ObjectPascal along with the implementation is a good candidate for being used in many areas as generic well thought out language along with the IDE.
As for the article: I think it is a good move on Idera's side. To call it corruption is disingenuous I think. Many corporations are using the same tactic. It is friggin business.
These are not in Free Pascal 3.0.6 (used in the latest Lazarus release) but they are in trunk and will be available in Free Pascal 3.2. I think they are also available in Delphi since a while now.
Corruption matters aside, I honestly think choosing a non-standard technology is a good move. Reading the news article, you see that the students mentioned are in trade schools. Turkey needs the trade school students to continue doing trades (there's a shortage of tradespeople), so it would make no sense flooding the javascript/c#/python developer market with trade schoolers now thinking they might make lots of more money despite not having any training on software development. We already have enough lemons in the developer market as it is.
So if they learn Delphi, they can use some software automation to make their jobs easier, and they can easily learn another language if they turn out to be really good at this new thing. After learning an OOP language, learning a new one takes at most a week.
Honestly, they could maybe start a desktop app start-up.
The web craze hasn't infected the entire planet (yet), and there's many small companies that require different tools and can't afford the big name packages or they can't find something matching their requirements.
It's an interesting concept. Flood the market with Delphi programmers, then companies will accept Delphi solutions, and start asking for them too. But also the good programmers won't leave the country because outside of Turkey nobody is asking for Delphi.
* New things are typically more popular than older things.
* People not using ObjectPascal / Delphi love to hate on it.
* People using it feel outraged at the injustice, pointing out it's merits.
I have been using Delphi for about 30 yrs it seems. I have a love / hate relationship with it. Love the language and the ability to rapidly get the program I want created. Hate that version after version, the IDE STILL has stupid bugs; that the built-in help seems to get worse and worse with time (I don't want a slow web browser showing me Microsoft C calls and all sorts of irrelevant nonsense), and get very annoyed when having to get required custom components installed before being able to open a project using the components. And I REALLY dislike that they charge so bloody much for it. For business reasons I had to purchase a license that cost a few thousand dollars. Like 2 weeks later, sales people were calling me encouraging me to spend a similar amount to upgrade to the newest version that had just come out. They must have only a handful of paying customers and depend on the few to keep their entire business afloat.
In the UK during the nineties we had old versions of Delphi distributed on magazine covers. Magazines then carried numerous tutorials over the years that helped people get started on their programming careers when school computing courses had lost their way with a focus on IT. Computing in schools in the UK with the BBC Micro had been much more useful as a basis for learning programming, something Eben Upton called out in his Raspberry PI keynote at PyCon a number of years ago.
I recall discussions with other students in my first year of uni about how they learned to program real things for family and businesses with these tools. Native and efficient Win16 and later Win32 (compared to VB runtime) programs were an exciting proposition in the 90s. Delphi could be used to create things that weren't as viable with VB. Personally, I chose C++ Builder for some reason (probably because I had heard about the industry use of C++), but even it had interesting facets, like the VCL compatibility with the Delphi toolset.
That was exactly how I got my start as a programmer, except in Denmark. It is so hard to understand that today you can download Python, Ruby, Java or anything else you want for nothing, but back then those where a Big Deal.
I was curious a little while ago whether Delphi or something similar was still available for modern computers (I think it followed from the same question about MS Access and VB6).
Yeah i use it for many years. The language is good, not free of warts, but does the job perfectly fine. The IDE might be a bit confusing at a first glance, but it is easy to figure out and it is so responsive it puts every other IDE to shame (consider that it runs and is usable on an original Raspberry Pi - which AFAIK has the equivalent power of a 300MHz PC). But the crown is the LCL/FCL (the VCL equivalent) framework with its tight integration with the IDE and visual designer (which you can use not just for GUI forms, but for creating actions, non-visual objects, collections, etc though obviously most of the focus has been on the GUI designer).
Here is a simple tool i wrote in a couple of days in Lazarus:
...but those are run-of-the-mill tools that i haven't available anywhere. Also i have a bunch of other tools i do not have screenshots of and there might be some other stuff on the server i do not remember :-P.
I am currently using Lazarus for an open source project. I develop and test in Windows and Linux. Lazarus is feature rich and quite stable (barring a few minor exceptions). Package installation can be quirky, but you can live with that. The IDE is reasonably capable in code traversal and refactoring. If you are comfortable with Object Pascal and if you are targetting the desktop platform, definitely worth a go.
Lazarus gives you rich, visual, native, multiplatform (OSX, Linux, Windows) GUI applications for free. I think also Android (and iOS?), but haven't checked.
However, in my personal opinion, Pascal has not really kept up with the sort of creature comforts that nowadays even C++ affords the programmer. The IDE (Delphi or Lazarus) also don't provide the kind of help Eclipse gives you when using Java, even though Pascal may feel as verbose sometimes.
Idera (nee Borland) must be stoked, they potentially just created 1 million new Delphi programmers in a 2nd world country. I'd add a bullet point to the sheet.
* One million Turkish kids
This isn't necessarily corruption. And we have no idea what they paid. The internet is lousy in Turkey, having a stand alone system with documentation, an IDE and a great debugger will work really well in that environment. Pascal is a perfectly fine language.
In my universe they started using Racket and The New Turing Omnibus (for middle school) and then The Little ____ Books [2] and then on to Structure and Interpretation of Computer Programs [3]
Um, what? I just signed up for fiber in Istanbul, lowest plan, 25mbit, at dirt cheap $11 a month — unmetered. Meanwhile my San Francisco apartment, Comcast charges me $67 a month for a 50mbit capped one.
While there is some variance in availability (just like any other country) Turkish infrastructure is generally first-world. It is for political reasons that it gets demoted into the second, but ultimately we’re talking about a place with a $25k~ GDP PPP per person [1]. That’s more than Greece’s, and climbing towards Italy’s.
I go to Turkey regularly and I always had a very good bandwidth on 4g, even in the middle of nowhere in Anatolia.
The network is much, much better than here in France.
I guess the geography of Turkey helps a lot there since they usually always have a good vantage point to put antenna.
I don't know why people in this thread seem to think that Turkey is a poor developing country. It's not. Even with the recent political issues and the economical crisis, it is much better than a lot of country in Europe and in the EU.
I think many people here genuinely don’t have much of an understanding of what they’re talking about most of the time, and you just catch it for the things that you personally know about. Makes you think about what one misses and takes as fact based on comments because you don’t about other topics.
Also, good LTE availability is also probably because it’s easy to place towers on top of flats legislatively speaking, and due to ruthless competition between three carriers.
I’m sorry if that sounded rude, it wasn’t meant to be. Ultimately though, you’re using the argument to paint an incorrect picture and then operate within that picture to make further claims. If you think it was a weak point, or not relevant within the context, it’s generally best to keep it out. I do pretty heavy cleanup after I write comments myself to not look like I’m implying something that I’m actually not.
> I don't know why people in this thread seem to think that Turkey is a poor developing country.
In the EU, there is a lot of prejudice against Turkish people because of the decades of immigration. Think of how most Americans stereotype Mexico and Mexican people, and that's roughly how many people in the EU regard Turkey.
In the US people don't really know anything about Turkey, aside from a vague idea that it's "middle eastern". Honestly I wouldn't be surprised if a huge percentage of Americans think Turkey is all deserts and they speak Arabic.
Istanbul isn't the whole country and it is a huge place. The sibling comment mentions Antalya, another large city. Both are going to have ok internet. Ergodan has done well to support the rural population where internet service is lousy. And that is only one aspect of having a self contained system.
Arguing over internet speeds when it comes to choosing a system for kids to learn programming on was by far weakest argument. I should have just removed it, as it was a straggler that was going to die anyway.
I've been to most parts of Turkey and I can say the Internet infra in smaller cities are actually better than the bigger ones. Especially the cellular/LTE network (I use Turkcell).
You rarely have dead zones between cities and most towns but the Internet sometimes downgrades to 3G or Edge if you're in a super rural area.
Going to start a project in in FreePascal soon because it seems to be the only [not abandonware] compiler for a high level language that still supports targeting 8086.
FWIW OpenWatcom v2 (a fork by one of the original developers who, at least according to the perforce logs, was the most active pre-fork anyway) https://github.com/open-watcom/open-watcom-v2 should also support 8086.
Huh, I'm surprised to find that you're right, unless you count NASM. Randall Hyde last updated HLA in 2015 (and it didn't support the 8086 anyway), WalterBright last updated DMC in 2013, and SDCC doesn't support the 8086. But I remember the 8086 as being a lot of needless effort that we had to cope with because it had a large installed base: near, far, and huge pointers, EMS bank switching, shitty TSRs that would stomp your registers, and so on. MS-DOS made it worse.
Oh I did find this one, albeit I couldnt find much information regarding ot outside of a short reddit thread. Sadly it looks like support expires this year (although I'm sure it will still be stable enough to use in most cases)
Pascal isn't necessarily the worst choice to learn programming in. After all, it was designed from the ground up for education and Delphi is one of the few environments around sporting a vb-style GUI creation interface. In high school, when i could barely program i still managed to utilize delphi to run some physics calculations. I suppose Java or C# makes more sense at the college level. But below that when the vast majority arent going to be programmers and the goal is to get them an idea of what programming is about i could think of few superior choices, if any.
This is not BUY. It is an agreement to supply the students within the curricula of 12 different courses for students to apply the projects using Delphi. It also covers an agreement t provide monthly scholarships to successful students.
> Getting object-pascal back into universities and education is very important. Not just for Delphi as a product and Embarcadero as a company, but to ensure that the next generation of software developers are given a firm grasp on fundamental programming concepts; concepts that represent the building-blocks that all software rests on; a curriculum that has taken heavy damage from the adoption of Java and C# in the early 2K’s.
doesn’t sound very convincing. Not a Java fan at all and never used C# since AFAIK it’s mostly used in the Microsoft ecosystem (I heard very good things about it though), but what fundamental concepts can’t be taught in a Java & C# curriculum that can be with Delphi? The article unfortunately doesn’t expand on that.
The move from Pascal to Java made a transition from learning how to program a computer to learning how to build apps using java-like OOP and libraries. Most places where Java is taught don´t teach about computer registers, stack frames, pointers, memory management, etc, and how they work together. Or if they do it they do it superficially.
Java and C# are a morass of complexity. There is no job or project where you just use the language Java/C#, you have to pull their immense libraries and frameworks in too.
On the other hand Delphi's just Delphi. That's quite refreshing in a world where everything depends on everything else.
> Java and C# are a morass of complexity. There is no job or project where you just use the language Java/C#, you have to pull their immense libraries and frameworks in too
I used Delphi for years back in the day, and will always have a soft spot for it. But your claims here are simply not true - the .NET standard library is huge, and you can get a lot done without any other packages.
Because most jobs and projects have complex requirements that aren't satisfied by the standard library of ANY language. But that's irrelevant for teaching.
The Java/.NET stdlibs are huge. They are more than sufficient to teach basically any of the foundational skills. Then if you want to learn Hibernate or ORMs, no problem, that's only a small extra step.
is this true today? Back in the day it was Delphi + JediVCL + JediCL + plus lots of other different components that looked better than bundled ones. Does it have a package manager or you still need to install a bunch of EXEs?
Students will be taught a language they'll never ever use in real life. It was paid for although there're tons of free languages for every platform and every paradigm.
I guess someone from the government had just become significantly richer.
If the government bought into Delphi then dev jobs within the country will likely be in Delphi more and more as time goes on. They don't need to do what we're doing. There's more than one way to skin a cat.
Everyone is assuming incompetence/familiarity with old tooling but it's also likely that this is a corruption/kickback scheme with some local distributor
To my knowledge, the software was provided for free, there was no economic transaction. In fact, Delphi Community Edition is free to any student over the world. This deal adds support for teachers.
Object Pascal is a great language, with many modern features and very optimized. Delphi add to this the best WYSIWYG ide ever created.
But they could have used free pascal and save millions, though. This looks like your usual government corruption. At least this time they bought something useful.
Python doesn't have any standard graphical IDE or even GUI widgets. No modern language can create GUI applications with the ease of use of Delphi, except maybe .NET (which is based on Delphi).
I'm definitely not a Delphi diehard, but I tend to think it's a good thing to have computation done on my largely powerful enough, instead of it being done on a small VM at the other side of the world which doesn't provide me with any control over my data.
I have nothing to do with Delphi. But I miss the time when users were in control of their data, and you could still use your computer normally offline.
Try to create a browser gui application using javascript, see how many resources it uses and how much time it takes you compared with Delphi, and just then, get out of my lawn.
.NET is definitely the easiest possible way to do a widget UI, but it's not based on Delphi in any meaningful sense. Its closest ancestor is Java, via the short lived "J++" https://en.wikipedia.org/wiki/Visual_J%2B%2B
(Android later did basically the same thing with Dalvik)
I think the parent comment meant "philosophically" based on Delphi since Anders Hejlsberg, the creator of C#, was also the creator of Turbo Pascal and chief architect of Delphi. He left Borland for Microsoft in the mid-90s.
Let’s not forget that the original chief architect of Delphi and the lead architect of C# since its beginnings are the same person so I would dare to say there had ro be some influence sneaking in.
Not only that but Delphi has tremendous educational potential due to fast feedback loops. There was a blog post once on HN where one of Delphi authors discussed how they designed IDE and the language to be friendly for newcomers.
Leace: "Not only that but Delphi has tremendous educational potential due to fast feedback loops."
Agreed completely!
Not only that, but an argument could be made that the TIME that a given body of source code takes to compile -- can have a huge impact (positive or negative) on programmer productivity...
Case in point: The Linux Kernel (written in C)...
You make a change, even a small one, and you're probably going to wait for HOURS for it to compile...
HOURS...
Before you can run it, to know what your change accomplished (or didn't accomplish!)...
HOURS...
If the Linux Kernel was written in Delphi, compilation would take no more than a few MINUTES, even on a modest machine, and possibly a lot less, possibly seconds, depending on the dependencies of the code that was modified...
That's the technological beauty of a single-pass compiler that caches precompiled source and its associated symbol tables (and only recompiles what's needed, only when it's needed)...
Which change-compile-test-feedback loop do you think would make a programmer more productive?
?
Hint: Even a non-programmer could easily know the difference...
Yes, there are languages which are more popular, more attuned to web development, more Lambda-esque in nature, and these things are virtuous, to be sure -- but in terms of raw compilation/run/test/change/iterate speed (aka productivity), Delphi smokes all of them...
For a programming job in the U.S., with many employers using differing technologies, it may be a loss, but for education, for the ability to learn how to think (as a programmer) and subsequently grow into other tools/technologies, it's a big WIN.
> Case in point: The Linux Kernel (written in C)...
> You make a change, even a small one, and you're probably going to wait for HOURS for it to compile...
I've done this before. For a small change in a .c file, it takes less than a couple of minutes in a not-so-fast computer. It only has to recompile that .c file, do a partial link of the subsystem, do a final link of the whole kernel, and a few other auxiliary processing steps. It takes more time to reboot the machine or VM with the new kernel.
Even compiling the kernel from scratch is fast. Looking at a Phoronix benchmark (https://openbenchmarking.org/showdown/pts/build-linux-kernel), it takes less than 15 minutes on all systems tested. Some systems can compile the whole kernel from scratch in less than half a minute.
In what OS and with what projects are you trying it? I'm using Lazarus since 2006 or so and the last time i remember it being unstable was back in 2008-2009. It has been a very long time since i even saw the IDE crashing, let alone getting a feeling that it is unstable.
(note that i'm using Windows and mainly with my own projects and components and i only use the components that come with Lazarus)
Nope, still unstable, you still need to chase and file small bugs, still no devexpress, either. But I have to admit they have done great work with the IDE during the past 5 years.
It depends on your use cases, are you just going to pop up a message box? Are you going to develop an ERP? c# and delphi both have devexpress, so apart from delphi's execution speed being faster (in my experience) they aren't really that different. Delphi does require you to manually cleanup memory at finally blocks, unlike c# which does garbage collection. Delphi has a design-time mode which is unique among the languages and is able to show live data from a database while developing master-detail forms and grids.
I remember studying with Delphi, don't remember any specific advantage for studying compared to let's say Java. On the other hand I remember many things seemed illogical.
The number of small scale desktop applications (like restaurant accounting/billing or tax management) in Turkey or similar markets exceeds all forms of mobile/web apps combined. In my home town in Iran, C# desktop developer is the number one job offer for the last 10-15 years. The market is full of small businesses that need simple desktop apps to run the business.
- Because you still need to bill your customers even when the net is down or slow,
- It works faster and more reliable on old, low on memory PC that you probably have. Also can work with old printers, barcode readers and pretty much anything out there,
- Power of habit (a big deal),
- Don't want to keep your accounting details on a remote server. This is probably of less importance for restaurants, but very important point for various trading companies, as it's not uncommon for someone to bribe accounting firms to leak info on competition.
Because that's what the jobs that are hiring are for in the place the GP lives? I mean, I'd rather browse HN than do work all day, but nobody's going to pay me for that.
I was an early web developer who transitioned into a modern one as time passed but I've moved back to desktop application development as of late because that's what was hiring in my area at the time I was looking for a job and I simply am not married to a particular technology.
Obviously there are people involved in the process of building these desktop apps who aren't the ones who decide they'll be desktop apps. But somebody is making that decision. I'm asking what leads that person to make that choice. Is it beneficial to the restaurant as a business? How?
I'm not asking about why people are willing to do what their boss asks for or their customers offer to pay for.
Sure you can, Brian, but those things aren't relevant to a simple line of business app like that. And I agree that it shouldn't be in the cloud; it should be on a Raspberry Pi in the back room of the restaurant, next to the Wi-Fi. Or, well, a Chinese clone, since you wouldn't want an Iranian restaurant to be dependent on imports from England.
Mods please change the title to remove "buys", the article changed it's title to "Turkish ministry of education secures free access to Delphi for an estimated one million students".
While everyone is trampling over each other to get into the tiny little door (the SaaS/FAANG/npm/golang/frontend/iOS scene), they found the smaller side door that no one else is taking.
Delphi is good for ordinary line-of-business software, all the boring back office software that people take for granted in first world countries.
Is it a good teaching language? I admit ignorance, so this does make me want to find out more.
I think more obvious options would be something like python for it's practicality, and something like clojure for elegance and more advanced programming concepts.
And they're free. I hope this isn't a case of graft.
Python & Java and .Net has quite a bit of traction in Turkish software industry. I believe Delphi is mainly used in healthcare but has been losing market share for years.
I think this is just another money embezzlement scheme by Turkish official, which shouldn't be that surprising unfortunately.
I expected to see people complaining that a government spend tons of money buying licenses when there are hundreds of other languages that you can use for free out there, but instead I saw people saying Delphi is good, Delphi is bad, Pascal whatever.
Started programming 14 years ago with Turbo Pascal. It was amazing. Good days. I remember having so much fun coding a command line application, full of blinking colors, colored text and stuff. Always have been a graphics inclined programmer.
I see it as a valid learning tool, a modern alternative to a Basic variant, however later on I would complete the curriculum with something with a bigger market penetration.
i have no idea why delphi still seems so popular in the middle east, a large number of mobile phone tools are still coded in delphi but ive never really understood why
Before everything came with an UI builder, there was only Visual Basic (before dot niet) and Delphi for building UIs quickly. But with VB you needed to switch to C++ for low level functionality, while with Delphi you could just do it in the same project. Including inline assembly.
Those days are gone, but the legacy still remains.
For this deal though, I guess Embarcadero is desperately looking for something that looks like a sale. All the cool kids in the west have switched to shit web UIs and they're probably left only with a few legacy customers.
Edit: Yes, the deal is most likely bribery. Doesn't make Embarcadero less desperate. Their fault for going enterprise and pricing Delphi out of a hobbyist's reach.
Edit 2: Sheesh, cheapest Delphi license is 1699 eur... back before Borland (sorry, Inprise) got sold i think it started at 300...
Edit 3: It's still much cheaper than Qt at 5500/year. This is how great platforms die.
> Sheesh, cheapest Delphi license is 1699 eur... back before Borland (sorry, Inprise) got sold i think it started at 300...
The cheapest version actually started at $99 and that was up to Delphi 5 IIRC. Later versions bumped the price to $199 (and i think there was a $99 for non-commercial use) and then quickly ascended to thousands.
I think it was after Delphi 5 that they also renamed themselves to Inprise.
We've banned this account for breaking the site guidelines. Political flamewar is off topic here, regardless of how right and/or righteous your cause is.
Really? The Nantucket one? I remember it, perhaps in error, as quite fast in compilation and I did write a couple of ERP systems in it back in the day.
It's a commercial product. Why on earth would you teach the kids something that they won't be able to use afterwards, when there are plenty of alternatives without that constraint?
It's like teaching kids to use Office, without even having the ubiquity argument.
> It's about the logic, not so much about the syntax.
So... Why Delphi then? And yes, many people do have a habit of sticking to exactly the environment that they were taught in. Defaults matter.
> And the office comparison is not valid, knowing Office is for many a very valuable skill.
As I mentioned in the other half of that paragraph, yes, you can make an argument for Office being valuable because of its ubiquity.
But that's a circular argument. Office is ubiquitous because they managed to convince educators, and now that seems to have made it basically impossible to kill off.
Trying to bootstrap something similar for Delphi is inexcusable.
But as educational tooling is that not a fault in itself? Surely we should be preparing students to at least use some mainstream languages, rather than pouring their skills and time into something that has a niche market value?
I think there's actually an argument for teaching students in something that isn't widely used/usable, as this (a) gives them the fundamentals but (b) essentially forces them to learn other more useful languages on their own.
As someone who had to use Eiffel, of all things, in college, I may be biased in this :)
IMO this is a limited view on what students need to learn to be valuable on the market. Delphi teaches you the value of experimentation through small feedback loops. For novices that just start programming this is critically important.
Absolutely, I don't entirely know what would be the best thing for students. In the end students should be taught to disrupt the industries they join not propel mainstream practices. So there is something to teaching them with more niche languages, that help them think differently to what is currently on the market! Thanks for sharing.
I then found out that they were being taught to use Borland Turbo C.
I suspect the case for this is similar: Some person who once upon a time learnt to program and then never practiced nor developed their skills somehow got a job teaching programming, and is now trying to apply the ancient tools they were taught somewhere around the time when some fish decided to walk on land because its all they know.