The Julia thread - Page 1
Forum section: electronics / general

author: SiliconWizard
author_rank: Super Contributor
timestamp: January 06, 2022, 07:15:22 pm
content: So, probably like many of us here, I had heard of Julia, but never really got interested.I very recently stumbled upon a conference about it, and it got me curious. Then I read docs, downloaded Julia and played a bit with it. I think it's worth a look, especially for people who don't like or want an alternative to Python for a range of applications, in particular numerical stuff, graphing, etc. Can also be an alternative to Matlab.https://julialang.org/A couple additional links that I've found useful so far:https://docs.juliaplots.org/latest/https://www.matecdev.com/posts/julia-fft.htmlhttps://docs.juliadsp.org/latest/contents/What are your thoughts? Does anyone use Julia here?

author: DrG
author_rank: Super Contributor
timestamp: January 06, 2022, 07:56:43 pm
content: Quote from: SiliconWizard on January 06, 2022, 07:15:22 pmI don't know, I am reading about it and, it does sound interesting. I need to learn more about - for example, the plots - how is device-dependency handled...if I were using one of those example plots, how would I use it on a typical PC screen or a little oLED screen. Like I said, I need to learn more and it would be a big investment in time and effort - but the thought of a python alternative is appealing. Thanks for posting - I did not know about it and have bookmarked it.

author: xrunner
author_rank: Super Contributor
timestamp: January 06, 2022, 08:21:33 pm
content: Interesting. I went through one tutorial at Julia academy and they were using emojis as variables. Well that's new to me!

author: SiliconWizard
author_rank: Super Contributor
timestamp: January 07, 2022, 12:30:06 am
content: Quote from: xrunner on January 06, 2022, 08:21:33 pmIt fully supports UTF-8 even for identifiers, which can be cool for some things, like using the greek alphabet, and obviously useless for some others.

author: Mattjd
author_rank: Regular Contributor
timestamp: January 07, 2022, 10:53:47 pm
content: I prefer Matlab to Numpy for purely numeric things strictly because of syntax but I don't find it compelling enough ditch the inarguably better general programming that Python provides to use favor Matlab.Then you have big large scale modeling tasks with possible porting to hardware platforms. Simulink + Matlab win hands down here and afaik, the large majority of automotive and aerospace companies operate in this fashion.I'm not sure what Julia would provide over Python in general computing and good enough numeric computing syntax to favor it. Might be worthwhile, I just haven't had a reason to want to try it. I heard Julia has multiple dispatching, you can do this in Python with descriptors/decorators, that might be why I would like to try it. I heard multiple dispatching in Julia is far superior to the version provided by python. Which isn't a built in but an extension constructed through normal exercise of the language.On the big large scale modeling tasks and porting to hardware I doubt it even comes close to Simulink + Matlab and don't think I even want to bother looking into it. I could be completely wrong and its awesome but I don't know of any companies that come close, let alone an open source project.

author: brucehoult
author_rank: Super Contributor
timestamp: January 08, 2022, 12:04:30 am
content: I've been following the growth of Julia but haven't really tried it yet.I'm very happy to see a lot of ideas from the Dylan language that I was actively championing from 1998 to around 2010 (and used to win a few prizes in the annual ICFP Programming Contest) make it into a proper compiled language that is gaining serious popularity.

author: SiliconWizard
author_rank: Super Contributor
timestamp: January 08, 2022, 12:26:35 am
content: Quote from: brucehoult on January 08, 2022, 12:04:30 amI hadn't until very recently either. But I think it's worth a shot.Quote from: brucehoult on January 08, 2022, 12:04:30 amI never really got to know Dylan, although I remember another discussion mentioning it. What are the ideas you're mentioning that made it into Julia?

author: brucehoult
author_rank: Super Contributor
timestamp: January 08, 2022, 01:11:38 am
content: Quote from: SiliconWizard on January 08, 2022, 12:26:35 amDynamic typing, with optional type declarations for documentation, optimisation, and choosing which function to call.Generic functions aka multiple dispatchProper hygienic lexical macros. Most Dylan control structures (for example) are macros in the standard library, built on simple if/else and (recursive) function calls.Everything is an object.Everything is an expression.For examples of new syntax via macros, see:https://github.com/dylan-hackers/gwydion-2.4/blob/master/d2c/runtime/dylan/macros.dylanThese macros result (after optimisation) in the same machine code you'd expect from loops etc in C.

author: SiliconWizard
author_rank: Super Contributor
timestamp: January 08, 2022, 03:11:18 am
content: I'm just reading about the macro system in Julia, and yes, it seems pretty powerful. I suppose it's close to Dylan macros, although I have a bit of a hard time telling for sure at the moment.Yes the typing system and the multiple dispatch are pretty nice.One thing that you note when starting with Julia (and I've read that was a common complaint) is that loading modules, and even running functions for the first time takes a while. It's due to the fact all functions are JIT compiled. But once they've been compiled, it becomes extremely fast. At the next session though, everything gets recompiled again. (There are ways of caching it and saving the result for later, didn't quite get into that yet, but there are caveats.) Of course it's all due to using a JIT compiler. Once things are compiled, it beats the pants out of Python and Matlab any day as far as I've seen. (Sure you can use modules written in C with Python, but with Julia, there's virtually no need to write C modules.)

author: PKTKS
author_rank: Super Contributor
timestamp: January 08, 2022, 01:37:09 pm
content: annnhhh a small BIG problem imho...Having LLVM and GPU dependency today it means we aredepending on GPU manufact. madhouse good will andcash flow business ..which .. annnhhh is ... like... a black box tunnel with no light anywhere..Paul

author: rstofer
author_rank: Super Contributor
timestamp: January 08, 2022, 07:03:42 pm
content: If you want to have fun with MATLAB and parallel computing, just use some version of the newer NVIDIA graphics cards with GPUs. Yes, this requires the Parallel Computing Toolbox but you can play for 30 days free (I am).My HP Envy All-In-One has an NVIDIA GTX 950M with 640 CUDA cores - this is tiny when compared to the RTX 3080 with 8960 cores.The MATLAB Deep Learning Toolkit (which I own) has a digit recognition example and the training time using only the CPU is on the order of 25-26 seconds. With the GPU, the time falls to 15-16 seconds. That is a tiny problem where the 10,000 images are 28x28 pixels. I am saving on the order of 40% in execution time on a relatively trivial classification problem. Just wait until I get rich and buy that Dell Data Science Laptop - like that will ever happen.https://www.dell.com/en-us/work/shop/dell-laptops-and-notebooks/precision-7760-data-science-workstation/spd/precision-17-7760-laptop/xctop776017dswsus_vpWant more fun? Are you a Fortran Programmer? I am...There's a book "CUDA Fortran for Scientists and Engineers" written by a couple of NVIDIA folks. The Linux only HPC (High Performance Computing) SDK includes a Fortran compiler. The laptop comes with Ubuntu 20.4. There's probably a reason for that. The Laptop version of the RTX3080 has only 6144 CUDA cores but that seems like a lot for anything I'll work on. With 16GB of CUDA memory, you can multiply some awesome arrays.This stuff is a lot of fun!BTW, the standard NVIDIA toolkit contains a C/C++ toolchain and there is a Windows version.The cuBLAS library recreates the Basic Linear Algebra System library optimized for CUDA computing. It's included.But using MATLAB with CUDA is where things get to be really fun! Particularly for Deep Neural Networks.

author: SiliconWizard
author_rank: Super Contributor
timestamp: January 08, 2022, 07:57:28 pm
content: Thanks, this is interesting but makes absolutely no mention of Julia, which is the topic here. =)Next thing you know, there will be a herd of "Pythonists" invading the thread. If we could avoid that... unless, of course, they talk about Julia. Then they are welcome.And I didn't get PKTKS' rant. (As often...) What's the link between using LLVM and being dependent on GPUs?

author: rstofer
author_rank: Super Contributor
timestamp: January 08, 2022, 09:07:17 pm
content: You're right, of course but I did just find out that Julia can use Fortran libraries. There appears to be a way to use Julia for CUDA programming and given the visualization capabilities of Julia, the language might actually be useful. Maybe I can find some examples.It is unlikely to pull me away from something mainstream like MATLAB but it could be in the running with Fortran.I term MATLAB as mainstream as the local university has a required course for first semester STEM students and they use it extensively through the remining terms. I'm actually amazed that NVIDIA supports Fortran but I guess they are playing to the engineering and scientific communities.

author: rstofer
author_rank: Super Contributor
timestamp: January 08, 2022, 10:06:34 pm
content: Quote from: PKTKS on January 08, 2022, 01:37:09 pmLacking an established standard for CUDA cores, I don't see how there can be multiple sources. It doesn't seem that the other manufacturers want to compete in that marketplace. I suppose there could be a shim layer to convert nvc and nvfortran code to some other architecture but I don't see it optimizing well.NVIDIA is HUGE in AI and they're spending a lot of money on developing applications that run on CUDA, Tensor Cores and other technologies. It's no wonder they own the market, they have a bunch of really smart math types working on this stuff.Since these compute capabilities are a natural outgrowth of NVIDIA's graphics business and, in fact, are required for high performance graphics, I don't see them going away as long as there are gamers and Bitcoin miners continuing to buy high end graphics cards. Look at their Market Cap and 5 year stock price. Pretty impressive!FWIW, some of our national laboratories are working with NVIDIA to come up with open source compilers. This may allow other manufacturers to get into the market with compatible hardware/software.

author: magic
author_rank: Super Contributor
timestamp: January 08, 2022, 10:18:38 pm
content: Quote from: rstofer on January 08, 2022, 09:07:17 pmThat's exactly the case. They even bought an HPC compiler vendor (PGI) a few years ago.

author: Nominal Animal
author_rank: Super Contributor
timestamp: January 08, 2022, 10:53:44 pm
content: Quote from: rstofer on January 08, 2022, 10:06:34 pmPeople like me who do GPGPU HPC stuff useOpenCLinstead of CUDA. Unlike CUDA, which is NVidia-only, several vendors support OpenCL.It is worth the difference to me to not be dependent on a single vendor –– or more importantly, dependent on the black-box support of a single vendor.

author: SiliconWizard
author_rank: Super Contributor
timestamp: January 09, 2022, 12:25:50 am
content: Yeah. Julia can also use OpenCL using a number of packages:https://opencl.org/coding/languages/julia/I would certainly stay away from CUDA as well.

author: rstofer
author_rank: Super Contributor
timestamp: January 09, 2022, 01:31:59 am
content: Quote from: Nominal Animal on January 08, 2022, 10:53:44 pmMakes all the sense in the world!. OTOH, I am just a simple hobbyist and I want an end-to-end solution much like I get with Xilinx. The same vendor makes the hardware, distributes the tools and provides a forum, videos and examples to get the beginners started. At some point, I'll look into OpenCL to see what it's about. The thing is, I like Fortran having used it since 1970 and that may be the biggest driver for me even getting involved with CUDA.As Julia supports CUDA, it is also of interest. I need to wander through the web site.I just watched the Flux.jl video and constructing a DNN in Julia is a lot like doing it in MATLAB. Just layers and layers stacked together, Very nice!

author: SiliconWizard
author_rank: Super Contributor
timestamp: January 09, 2022, 01:36:24 am
content: The language itself is pretty advanced. I was not expecting that either until I took a deeper look!

author: rstofer
author_rank: Super Contributor
timestamp: January 09, 2022, 01:54:06 am
content: There's a lot to like in Julia. I need to get serious and do something with it.

author: PKTKS
author_rank: Super Contributor
timestamp: January 09, 2022, 09:20:41 am
content: Quote from: SiliconWizard on January 08, 2022, 07:57:28 pmAmazing how labels attach.. where is rant related i have no idea.. you posted the link yourself.. have youevenreadthe first call?https://julialang.org/Quoting them..Julia in a NutshellFastJulia was designed from the beginning for high performance. Julia programs compile to efficient native code for multiple platformsvia LLVM.Anyone experienced with LLVM already got that it is meant to workaround GPU proprietary Instruction SetSO ... SOOOOO.. if you deposit your hopes in a language biased towards that...Geez.. you are in the hands of GPU makers which shrunk the market to 2 options in the last decades...What is good about that? Rant?give me a break about this nonsenserantthingPaul

author: rstofer
author_rank: Super Contributor
timestamp: January 09, 2022, 04:52:40 pm
content: Quote from: PKTKS on January 09, 2022, 09:20:41 amLike any other market, there is a cost to enter. Apparently, other manufacturers and potential manufacturers don't see a way to enter the market and make a profit. If it was easy, we would be knee deep in competitive graphics boards and programming them would take on an Arduino feel.NVIDIA, OTOH, has invested a HUGE amount of money developing the technology and backing it up with free tools. Just the cost of feeding the researchers, engineers, mathematicians and technical writers must be costing them a TON of money. From their stock price, I have to assume the market thinks they're doing excellent work.Don't get me wrong, I have always hated the NVIDIA card in my Linux machine. When I bought it nearly 20 years ago, I had to rebuild the drivers every time the kernel changed and it wasn't a pleasant prospect. Closed source drivers kept me away from NVIDIA for a long time.Things change, I want to play with massively parallel computing. Where else can I buy an 8192 FP core processor? What other company has all of the bits and pieces to make it possible for a hobbyist to work on such things. And their community forum is excellent. Couple the hardware with Julia or MATLAB and even the elderly can play in the big leagues.We're talking multiple teraflops of compute power in a laptop. We went to the Moon with machines performing, at best, 3 megaflops in a CDC 6600 mainframe. I can have more compute power in my workshop than existed on the entire planet in 1969. Without the huge electric bill!Anybody want to compete? Well, step right up! Go hire a raft of the smartest people on the planet and give it a shot! We'll know from the stock price whether they are making money.To bring this back to Julia, it certainly looks like the language has all of the libraries and such to take advantage of NVIDIAs offerings plus a way to adapt to newcomers. I don't know that Julia will catch on like Python but it certainly has possibilities.The Julia code for digit recognition over the MNIST dataset is readily available:https://github.com/crhota/Handwritten-Digit-Recognition-using-MNIST-dataset-and-Julia-Flux/blob/master/src/Handwriting%20Recognition.ipynbThere is a ton of comments and the code is pretty easy to follow. I may eventually start to like the Jupyter Notebook approach.In terms of Julia and Flux, here's a gentle introduction:https://fluxml.ai/tutorials/2020/09/15/deep-learning-flux.html

author: Nominal Animal
author_rank: Super Contributor
timestamp: January 09, 2022, 05:33:20 pm
content: Quote from: rstofer on January 09, 2022, 01:31:59 amThere is nothing wrong in relying on CUDA, though, if you accept the single-vendor dependency. Like said before, alotof scientists rely on it (via the software they use) and use it happily. Me, I'm a toolmaker myself, so my attitude differs from those who just use the existing tools to get useful interesting results.Indeed, the CUDA vs. OpenCL in HPC is a bit of a hot potato, because currently, with CUDA, you can get more out of NVidia hardware, which is common in HPC clusters.(It gets a bit nasty if you drag in the topic of "reproducible results" when that exact hardware is no longer available.)

author: rstofer
author_rank: Super Contributor
timestamp: January 09, 2022, 05:47:13 pm
content: Quote from: Nominal Animal on January 09, 2022, 05:33:20 pmI've been retired for 18 years so dependency issues are not a concern. What is a concern is documentation. I'm not so much a developer as a copy-and-paster. I need examples! Community forums are highly regarded and Julia has that covered! They have some outstanding projects and videos and they don't assume I have a PhD in Applied Mathematics.From what I have seen of CNNs, all weights and biases start with a random value. Results, run to run, are not exactly identical. There's some kind of tolerance, I suppose. I have yet to tumble to how they separate a local minimum from a global minimum when there is a mountain in the way in thousand dimensional space. Working on it...

author: SiliconWizard
author_rank: Super Contributor
timestamp: January 09, 2022, 06:51:01 pm
content: Quote from: Nominal Animal on January 09, 2022, 05:33:20 pmOf course. It's like with everything else in computing. Either you want something fully open and portable, or you want maximum performance. Both are usually mutually exclusive, except maybe in very rare cases.Regarding Julia, both are supported in various ways, so you can pick what works for you.

author: rstofer
author_rank: Super Contributor
timestamp: January 10, 2022, 09:11:56 pm
content: Julia likes matrices and it just so happens I have a small Linear Algebra example written for MATLAB. So, I transmogrified it to run in Julia. There are a bunch of syntactic differences...When I wrote the code for MATLAB, I chose to start with a 6x7 matrix where the 7th column was the value vector for the simultaneous equations. Hence the bit where I have to extract the 7th column.Code:using Printf# A football stadium has a capacity of 100,000 attendees# Ticket prices:# Student = $25# Alumni = $40# Faculty = $60# Public = $70# Veterans = $32# Guests = $ 0# A full capacity game netted $4,897,000# Let S = number of students, A = number of alumni, F = number of faculty# P = number of public, V = number of veterans, G = number of guests# S A F P V G = valueM = [ 1 1 1 1 1 1 100000 # total number of attendees25 40 60 70 32 0 4897000 # total revenue0 1 -1 0 0 0 11000 # 11000 more alumni than faculty0 1 0 1 -10 0 0 # public + alumni = 10 * veterans-1 1 1 0 0 0 0 # alumni + faculty = students1 0 1 0 -4 -4 0] # faculty + students = 4 (guests + veterans)A = M[:,1:6] # extract 6x6 matrixB = M[:,7] # extract value column vectorP = (M[2,1:6])' # ticket price by attendee typeR = inv(A)*B # compute number of attendees by typeT = sum(R) # check total attendees = 100,000 CHECKU = P.*R # total revenue = 4,897,000 CHECKV = R'.*P # revenue by attendee type - transpose R from 6x1 to 1x6# then do element by element multiplicationlabels = ["Students", "Alumni", "Faculty", "Public", "Veterans", "Guests"]for i in 1:6@printf("%-8s %7d @ %2d %7d\n",labels,round(R),M[2,i],round(V))end@printf("\nTotals %7d %8d\n",round(T), round(sum(V)))Not that it will be efficient on such a small problem but the next step is to shove the computing off to the GPU - just for a drill.

author: SiliconWizard
author_rank: Super Contributor
timestamp: January 10, 2022, 09:14:46 pm
content: I suggest reading "Chapter 38 - Noteworthy Differences from other Languages" of Julia's documentation.

author: rstofer
author_rank: Super Contributor
timestamp: January 10, 2022, 11:07:01 pm
content: Quote from: SiliconWizard on January 10, 2022, 09:14:46 pmThat's up next! I had a heck of a time learning the ins and outs - Google is my friend! I am certain Julia has an easier way. MATLAB probably has an easier way as well. I wrote that code a few years back as a tutorial with all the steps commented and such. It's a start! Kind of the "Hello World" of Linear Algebra.I'll get to that reference in the next day or two. I just wanted some output.FWIW, I wrote the code using VS Code with the Julia plug-in. Among other things VS Code provides a terminal for the REPL functionality. Very handy for checking things like matrix size and values.

author: SiliconWizard
author_rank: Super Contributor
timestamp: January 10, 2022, 11:35:50 pm
content: Oh sure, there's a myriad ways of achieving the same, some more or less optimized and more or less "idiomatic". The doc is 1300+ pages. But I find it quite readable so far.Just for fun, a small example of defining a type, with an associated iterator, custom indexing, and showing multiple dispatch.Code:using Plots, Statisticsstruct DiscreteFuncfunc::Functioninterval::Tuple{Number, Number}n::IntendStepX(df::DiscreteFunc) = (df.interval - df.interval) / df.nBase.iterate(df::DiscreteFunc, state = 0) = state >= df.n ? nothing : ((x = df.interval + state*StepX(df); (x, df.func(x))), state + 1)Base.length(df::DiscreteFunc) = df.nfunction Base.getindex(df::DiscreteFunc, i::Int)1 <= i <= df.n || throw(BoundsError(df, i))x = df.interval + (i - 1)*StepX(df)return (x, df.func(x))endBase.firstindex(df::DiscreteFunc) = 1Base.lastindex(df::DiscreteFunc) = df.nVectX(df::DiscreteFunc) = [P for P in df]VectY(df::DiscreteFunc) = [P for P in df]mean(df::DiscreteFunc) = Statistics.mean(VectY(df))# Examples.df1 = DiscreteFunc(cos, (0, 2π), 100)mean(df1)plot(VectX(df1), VectY(df1))df2 = DiscreteFunc(x -> x != 0 ? sin(x)/x : 1, (-50, 50), 500)plot(VectX(df2), VectY(df2))

author: rstofer
author_rank: Super Contributor
timestamp: January 11, 2022, 12:36:13 am
content: Some of the differences from MATLAB are profound and likely will lead to much teeth gnashing. Consider:QuoteI REALLY need to digest these differences!

author: SiliconWizard
author_rank: Super Contributor
timestamp: January 11, 2022, 12:56:42 am
content: Quote from: rstofer on January 11, 2022, 12:36:13 amThat's a bit like Lua tables.You can use the copy() function to make a copy: A = copy(B)(of course, probably not to be abused - in general there may be other ways to achieve the same than having copies of arrays, depends!)Of course, you'll get a completely new vector if you add elements, for instance:Code:A = [1, 2]B = [A; 3] # one short way of adding an element to a vector, you get [1, 2, 3], while if using:B = [A, 3] # you get [[1,2], 3] as expected# in both cases, of course, A is unmodified if you further modify B

author: magic
author_rank: Super Contributor
timestamp: January 11, 2022, 09:30:32 am
content: Quote from: rstofer on January 11, 2022, 12:36:13 amYeah, that's not looking good for a dummy-friendly language.Computer scientists will get it, but mathematicians and physicists not so fast

author: brucehoult
author_rank: Super Contributor
timestamp: January 11, 2022, 09:45:04 am
content: Quote from: magic on January 11, 2022, 09:30:32 amIt's no different to C. Or Java. Or Python.Code:$ python -c 'a=[1,2,3,4];b=a;b=42;print a'[1, 2, 42, 4]In almost all languages "assigning" an object is actually copying a reference to the object, not the object itself. C++ is one of the few exceptions to this.

author: magic
author_rank: Super Contributor
timestamp: January 11, 2022, 10:12:44 am
content: Clearly they are buggy languages, then. Why would assigning something to b have anything to do with my a?Code:> a=[1,2,3,4]; b=a; b(2)=42; aa =1 2 3 4

author: brucehoult
author_rank: Super Contributor
timestamp: January 11, 2022, 11:32:48 am
content: Quote from: magic on January 11, 2022, 10:12:44 amLanguages aren't buggy. Programs are.

author: brucehoult
author_rank: Super Contributor
timestamp: January 11, 2022, 11:53:50 am
content: Oh, and JavaScript too:Code:$ node -e 'a=[1,2,3,4];b=a;b=42;console.log(a)'[ 1, 2, 42, 4 ]And Ruby:Code:$ ruby -e 'a=[1,2,3,4];b=a;b=42;print a,"\n"'[1, 2, 42, 4]But you'd like Perl. Maybe it's the true beginner's language?Code:$ perl -e '@a=(1,2,3,4);@b=@a;$b=42;print "@a\n";print "@b\n"'1 2 3 41 2 42 4

author: DiTBho
author_rank: Super Contributor
timestamp: January 11, 2022, 01:58:31 pm
content: Perhaps we should use two different operators"A ==> B" to assign the object pointer (B points to the same content of A)"A = B" to allocate a new content area, copy the content from A, and assign the pointer to B

author: rstofer
author_rank: Super Contributor
timestamp: January 11, 2022, 04:06:40 pm
content: By itself, it's not a problem. Most languages try to avoid the copy including Fortran. Certainly, the copy is wasteful of time and memory if it isn't truly needed. Where it can become an issue is for those familiar with MATLAB. Even in MATLAB, the copy operation is controllable with care:https://www.mathworks.com/help/matlab/matlab_prog/avoid-unnecessary-copies-of-data.htmlPass by value versus pass by reference has been a debate for 70+ years. By default, Fortran passes by reference and in modern incantations, this can be overridden. C is pass by value and pointers are explicit. Clearly, both schemes work and we use both in our daily lives. We just need to keep it straight.https://docs.oracle.com/cd/E19957-01/805-4940/z400091044b8In the end, it's just something to be aware of. This topic is of great importance in machine learning where the matrices are HUGE. Copying is to be avoided both in terms of time and space. We already have to copy the data from CPU memory to GPU memory and bring the results back. 12 GB on a graphics card seems a lot but it's only 1.5 giga qwords. Start throwing some 10,000x10,000 matrices of qwords around and it fills up fast. Yet the idea is to keep as much of the math inside GPU space as possible to avoid copying.

author: SiliconWizard
author_rank: Super Contributor
timestamp: January 11, 2022, 07:14:02 pm
content: This is a sane choice indeed.But it's interesting to see how something that may look as mundane as an "assignment" can mean different things to different people, and in turn to different languages.And it comes with the now old question of whether using the equal sign for assignments even makes sense.

author: rstofer
author_rank: Super Contributor
timestamp: January 11, 2022, 08:10:34 pm
content: Quote from: SiliconWizard on January 11, 2022, 07:14:02 pmNiklaus Wirth thought it made no sense and used := for assignment in Pascal as did the authors of Algol. It makes sense because the operator was described as 'becomes' rather then 'equal'. Equality is an entirely different concept and symbol '='. Other languages use '=' and '=='.Wirth shows up as one of the designers of Algol W in 1966 and later Pascal, Modula, Modula 2, Oberon, Oberon 2 and Oberon-07. A true luminary!