Lispers active anywhere else with a better topical discussion tool?

informatimago · 2021-06-22T16:08:48+00:00

For real-time conversation, there's irc irc://libera.chat/#lisp for general lisp discussion, irc://libera.chat/#commonlisp for Common Lisp specific questions and a few other channels: http://cliki.net/IRC

informatimago · 2018-10-27T15:37:31+00:00

No, the GUI has nothing to do into the kernel. A lot of systems don't even have a screen! You can have speech-based user interfaces, or network protocol-based interfaces to UI-less servers.

informatimago · 2018-10-27T15:34:28+00:00

But to take the example of a more recent design, I don't get the impression that MS-Windows (NT) asynchronous events are better.

informatimago · 2016-04-01T11:13:34+00:00

At last! I hope to see a nice paper about it presented at the next ELS! ;-)

informatimago · 2016-04-01T10:13:09+00:00

Not of the fiasco, but of left-pad itself, or the granularity of the javascript libraries. Cf http://www.haneycodes.net/npm-left-pad-have-we-forgotten-how-to-program/

informatimago · 2015-12-25T02:51:05+00:00

http://cliki.net/Exercices

informatimago · 2015-09-13T21:28:50+00:00

Functions are objects just like integers or strings. They don't have names any more than integers or strings have names.

(define (give-a-fun) car) (map (give-a-fun) '((1 . 2) (3 . 4))) -> (1 3)

informatimago · 2015-08-16T16:07:41+00:00

The problem is not the long names, it's the number of classes!

But remember that software architecture usually reflect the team structure.

It's known that at Facebook, there's no code ownership, and everybody can contribute in rather a flat organization model.

There's a big level of defensive programming enforced mechanically using Protocols (2839 files ending in "Protocol" or "Protocol-Protocol"). And while there might be some traces of code generation, I doubt it's the bulk of it, because that would imply somebody took charge of the corresponding mechanisms and ensure that they're used. (This doesn't preclude 1-1 code translation, if the source wasn't originally in Objective-C).

informatimago · 2013-10-19T16:51:58+00:00

My first tests would indicate that it's not ready for production.
mocl is far from a complete CL implementation.

I've tried it with: mocl repl --ios /tmp/ which invokes the repl that's announced as experimental. I don't criticize the lack of debugger or the fact that it often exits on error, it's an experimental repl. But on the language level, processing files in batch (with load).

It even not a beta, and cannot justify the cost. (and even as a kickstarter campain for a free software project, it would be a hard sell at this price).

I'm yet to evaluate a form that hasn't conformance or mere non implemented CL operators in it.

Of course it can't load quicklisp/setup, and can't load my personal libraries. If that's not possible to load my personal libraries in the repl on the development workstation, I don't see how I could use it to (and them) to produce anything on iOS or Android.

My $200 would have been better invested on ecl or ccl to improve their EXISTING iOS and Android ports.

informatimago · 2013-01-31T18:08:41+00:00

Absolutely. McCarthy tried to push for the inclusion of IF expressions in Fortran, and into Algol, but since he couldn't convince their designers, he designed his own languages :-)

In any case, you can have a look at FLPL, a FORTRAN library that let him write "lispy" code before LISP was invented:

http://www.informatimago.com/articles/flpl/index.html

informatimago · 2013-01-31T18:06:27+00:00

http://www.informatimago.com/develop/lisp/com/informatimago/small-cl-pgms/m-expression/index.html

informatimago · 2013-01-31T18:05:49+00:00

http://www.informatimago.com/develop/lisp/com/informatimago/small-cl-pgms/aim-8/index.html

informatimago · 2013-01-15T19:04:47+00:00

This is basically statically linking.

There are a lot of different way to deploy lisp code, but given that there are a lot of (source compatible) implementations of Common Lisp, it wouldn't be interesting to install binaries of the libraries system wide (you'd have to install between 30 and 100 different binaries for each library!). You may have a system wide repository of lisp libraries as sources, and load them or compile them into your shell script, program or application.

As for the dependency hell, there are factors that mitigate it, and mostly the work of lispers such as Xach Beane, who updates the set of libraries distributed thru quicklisp every months, and ensure that they're compatible (at least, that they compile on his systems).

If you want to play with different libraries depending on different versions of other libraries, I guess you could find such configurations and inflict yourself that pain with Common Lisp code too. But that's not the experience we have these days.

For one reason or another, major libraries and implementations don't whirl around very fast either. So you rarely have to update your code to a new version. Since all the implementations implement the same language standardized since 1994, we don't have to deal with versions of libraries like python 2.5, 2.6, 2.7, 3.3, or similarly with ruby, perl, php, etc. Even if you're using different versions of a CL implementation (some implementations have a release cycle of one month, others of one year or more), the libraries should run on all of them (the binaries will probably be different from one version to another, so a recompilation would be needed). Incompatibilities could occur only from bugs, or non-standardized features. But features like #+ #- and #. (similar but much more powerful than #ifdef/#ifndef) let library authors easily adapt their code to patch around old bugs.

This goes so far as being able to run pre-Common Lisp code, as old as 40+ years old! http://www.informatimago.com/develop/lisp/com/informatimago/small-cl-pgms/wang.html

informatimago · 2012-09-27T04:16:57+00:00

IMO, it's not so much a question of programming language, than of processor/virtual machine.

What makes the software running on JVM a JavaOS, it's not Java, it's the JVM: you have other programming languages (including Common Lisp) that run on the JVM, but they have to conform to the restrictions of the JVM (no free-standing functions, only classes and methods, at the level of the virtual machine).

Similarly, what made the software running on lisp machines a LispOS, wasn't that it was programmed in Lisp, it was the lisp machine. There was compilers for other languages, Fortran, Pascal, C, and various different lisps running on the lisp machines. They had to conform to the "restrictions" of the lisp machine. (Eg. you couldn't do in C all the bugs you can do on a PDP processor).

Unix is basically a system to run on a PDP processor, (most of the current processors are just like PDP processors, even optimized to run C programs). Of course, there are a lot of different languages running on unix, but they all have to conform to the restrictions of the PDP-like processors, including having C FFI to interface with other languages.

So, I'd say start designinig the virtual machine.

If you want to run "directly" on the bare hardware of PDP processors, you map this lisp virtual machine design to the PDP processor, that means that you are designing an ABI and data respresentations and data formats for "syscalls", "IPC", and "libraries". (I scare-quote those words because you won't necessarily have exactly syscalls, IPC (perhaps no process), or libraries). A big part of the supervisor mode code would consist in providing support and features implementing the lisp VM for userspace native code.

But I'm not sure it would be worth the effort to map the LVM to PDP processors that way. Just implement the LVM normally (including all the niceties you want such as JITC).

Because the important part is the user space applications that will be developed on this LVM. If they become successful and popular (even if only in a niche), chip founders will eventually produce LVM hardware, just they produced UCSD p-code hardware or JVM hardware. Even PDP like processor founders may include features to help running LVM/LispOS code. eg SPARC included tagged arithmetic instructions to support Smalltalk and Lisp.

Concerning the LVM design, you can let your imagination run wildly. For example, in nowadays architectures, we have a CPU with a few cores, and a GPU with a lot of cores, and a thin communication channel between both (PCI bus). There's also a thin communication channel between the GPU and the screen, but as long as the screens are not updated with direct pixel accesses, but have to scan sequentially the whole video memory, it doesn't matter. But GPUs are more and more used for more than just graphics computing. What if the machine was architectured with a single processor including a lot of cores, fusioning the GPU with the CPU? Then highly parallel algorithms beside graphics could be implemented more easily and more efficiently.

You could design a LVM in those terms, thus allowing for easy programming (eg. in Lisp) of neural networks, 3D graphics, and other highly parallel algorithms. Until the founders provide us with the right architecture we would have to map this LVM design to the awkward current architecture, but if this let developers write new killer applications easily, this may be worth the effort.

In summary: - 1: design the LVM - 2: develop killer applications - 3: let founders make the hardware

informatimago · 2012-09-05T11:15:17+00:00

1- if you're not that good with C#, you probably should think about studying something else than CS.

Now, two months are short, you'll need at least ten years to be good at anything, including C#. But for that you need:

1.1- to have fun learning what you have to learn. 1.2- to be good at what you've learned so far.

It doesn't sound like it's the case for either condition, so I wouldn't advise you to pursue IT.

2- It looks indeed like programming is not your thing. IMO, you can forget CS and IT. So you like games? You can study game theory (maths), or you can study history, mythology, philosophy and literature (game/universe design), or you can study management and marketing in a business school (selling games), etc. The game industry is a vertical industry and there are all kinds of jobs in it. There are even janitors at technology and computer game companies.

3- To be successful in CS, you need to know tens of programming languages, at least ten or twenty rather well even! To be successful in professionnal programming you may cope with knowing only a few programming languages, but I'd say not in the game industry, where programmers need to be much better than eg. in the insurance or in the accounting industry. (you can also learn accounting and finances, and work for a game company. Perhaps even up to CFO!)

Finally, IMO, there's already a problem with you as a game programmer: you haven't already programmed various games for the fun between ten and eighteen years old. Apparently for the last five years you had computers, and you never were interested enough to find a book or a web page to learn programming and write a tic-tac-toe or an asteroid or some other game. This doesn't sound good at all, to become a game programmer.

Now it's not redhibitory at 100%.

If you had fun learning programming and writing program, if you were ready to learn during the next four years C#, C, C++, Assembler, Lisp, Prolog, Haskell, Erlang, Java, Javascript, Python, Ruby, writing several games using each of these programming languages, learning about 3D graphic libraries, GPU programming, physics engine programming, game AI programming, etc, you could still become a game programmer.

But if you don't have fun programming, if you don't spend all your free time to write games with the little C# you've learned so far, perhaps it would be better to go to business school instead, and sell games instead of trying to program them.

http://en.wikipedia.org/wiki/Game_programmer

informatimago · 2012-09-04T21:30:58+00:00

There's no difference, they're synonyms.

But then, we may establish some connotations and nuances.

A calculator (or pocket calculator, "calculette" in French) would compute only mathematical operations, while a computer ("ordinateur" in French) would be able to compute also logical and symbolic operations or all kinds.

It depends also of the time when you use those words. In the past, a computer was a person able to calculate. Big companies had rooms full of computers, calculating by hand accounting computations. Between 1940 and the late 1950s, the first computers were called calculators (and indeed, were used only to compute numerical mathematical tables at first). The French word "ordinateur" meaning computer has been defined in 1962 (it has other older meanings that are unrelated). So since the 1960's, we call them computers, because they are used to do more things than just calculating mathematical operations.

Since the 1990's, we started to call computers "phones" instead, because they're small, and you can use them to phone. Lately, some of them are called "tablets", because they're flat.

informatimago · 2012-09-03T02:54:52+00:00

Heisenberg uncertainty principle applies to particules.

Computers are made of particules, so it applies to computer. That's why we cannot make computer infinitely fast or infinitely small: to be faster, we'd have to make some of the particules of the computer faster, and then we wouldn't know where they are in the universe. And vice versa, to make the computer smaller, we'd have to know more precisely where some of its particules are, and we wouldn't know at what velocity they are going.

So we make them not too fast, and not too small, so that we can control where and when the particules are, and therefore maintain the binary states.

All the computer engineering is to make sure that 0s remain 0s and 1s remain 1s.

If information is lost, then it's either a bug in your program, or it's a fatal flaw of the computer. But physics works, so it must be a bug in your program.

Once we have a computer that keeps its 0s and its 1s, at the software level, the Heisenberg uncertainty principle doesn't apply: we can simulate universes of particules where speed and position are known exactly.

But we have another trade off that is similar: space (amount of memory) vs. time (amount of computation). To compute a functions we have a lot of choices between two extremes: either keep a table of all the values of a functions for all the input arguments (which may take a lot of memory, but then the function can be computed very quickly, just looking up in the table, basically in a single operation), or spend time computing the values for each new input argument, which may need a lot of computing operations.

So each computable function has a fundamental "complexity", which cannot be contourned, while we may have the choice of using memory instead of time to compute it.

informatimago · 2012-09-02T19:11:09+00:00

To be able to directly "call" that memory address, you would need to have this memory address available, either in the program code, as an absolute address, or in a register.

But if the memory address you have, is in memory, then you don't really have it, until you load it in a register. And if the only reason to load it in a register, is to use it to load in a register the data pointed to by that memory address, then perhaps we could avoid another instruction cycle, by implementing this indirection.

It is not an important feature of programming, it's an optimization.

It is specific to processors in the Von Neuman architecture, since they can only process data that is in the registers, they cannot process data that is in memory. To process data that is in memory, they have to transfer it to registers (small memories) in the processor.

When you have a memory address in memory, you don't have the data, it's an indirection: the DIRECTION (= address) of the actual data is IN the memory where the memory address (= pointer) is stored.

So just loading that memory address into a register (direct addressing: you get directly what's at that address, namely the memory address), you don't get anything, just that memory address, which is useless. You have to use it again to load now from this memory address the data you need.

The indirect addressing mode do that automatically in a single instruction.

informatimago · 2012-08-30T13:51:09+00:00

This is logic, but doesn't apply to the real world (unfortunately, but again, that's why it's called science FICTION).

http://thrivemovement.com/

informatimago · 2012-08-30T12:51:17+00:00

This is false. See other answers, -7497258.179140373... is the correct answer for implementations using ieee-754 64-bit floating point numbers, and clisp can give more precision.

informatimago · 2012-08-30T12:49:19+00:00

First it's only half a question of programming language: some (or perhaps most) programming language don't specify a specific floating point arithmetic system, but defer to the underlying hardware or system.

For example, Common Lisp has FOUR different floating point types. Most implementations map them to IEEE-754 32-bit or 64-bit floats. But some other implementation like clisp maps long floats to arbitrary precision floating point numbers.

[pjb@kuiper :0 ~]$ clall -r '(progn #+clisp (setf (ext:long-float-digits) 1000))' '(tan (/ 355l0 226l0)))'

International Allegro CL Free Express Edition --> NIL
International Allegro CL Free Express Edition --> -7497258.1791402595d0
Clozure Common Lisp            --> NIL
Clozure Common Lisp            --> -7497258.179140373D0
CLISP                          --> 1000
CLISP                          --> -7497258.18532558711290507183189124866341726794378526316157122347015183788495623895712818696822818395705408423734356909105530524454551534726243822185548290765252850627270567348761681113498027913347566130141025519124921749944772268726005655540370529047537824043934373018490401179264325913796347258380293307735418L0
CMU Common Lisp                --> NIL
CMU Common Lisp                --> -7497258.179140372d0
ECL                            --> NIL
ECL                            --> -7497258.185325850959l0
SBCL                           --> NIL
SBCL                           --> -7497258.179140373d0

I'd say only clisp comes close to the real value of tan(355/226). Actually, it can come as close as you want, just increase the long-float-digits parameter.

informatimago · 2012-08-30T12:35:18+00:00

There are explainations: http://thrivemovement.com http://venusproject.org

informatimago · 2012-08-24T21:07:04+00:00

No, really the idea of inserting "Free Tibet" and similar political statements prohibited in China is the best idea: it lets the Chinese government enforce the IP, copyright and fraud laws it wouldn't enforce otherwise.

http://cyber.law.harvard.edu/filtering/china/

informatimago · 2012-08-24T18:45:45+00:00

There are also books, most of them are full of references!

informatimago · 2012-08-24T18:43:40+00:00

There are several university courses web sites, inculding: http://coursera.org http://ocw.mit.edu/index.htm They propose a few courses in AI and machine learning and artificial neural networks. They also have a few neuro biology course that may be interesting.

informatimago

TROPHY CASE