Lisp-homos can't do anything with their shit language

Josiah Fisher
Josiah Fisher

Remember the one time Common Lisp users were asked to make a simple text editor 100% with it and post runnable binary and sources, and they promptly used their magic language to deliver within a few posts because it's so trivial for super language like that? Well me neither, but I remember when they kvetched and dodged and cried and slided and adhomined two bump limit threads over three months.

Don't fall for their meme language, don't even associate with them. They are the worst cock suckers around, a real fucking disgrace to all programmers.

Attached: Kizuna.AI.full.2243657.jpg (769.84 KB, 1000x1333)

Other urls found in this thread:

clojure.org/community/success_stories
github.com/azzamsa/awesome-cl-software
youtube.com/watch?v=Ox2H3kUQByo&t=37m40s)
archive.is/oUEwA
archive.fo/mnbNo
wingolog.org/archives/2019/06/26/fibs-lies-and-benchmarks
gnu.org/software/guile/
guix.gnu.org/
gnu.org/software/mes/
web-artanis.com/
gnu.org/software/shepherd/
8ch.net/faq.html
github.com/atlas-engineer/next
github.com/emacs-mirror/emacs/search?utf8=✓&q=X11&type=
gtk.org/language-bindings.php
github.com/spk121/guile-gi
gnu.org/licenses/license-list.html
gnu.org/licenses/bsd.en.html
gnu.org/philosophy/why-copyleft.html.en

Camden Evans
Camden Evans

Remember the one time Common Lisp users were asked to make a simple text editor 100% with it and post runnable binary and sources, and they promptly used their magic language to deliver within a few posts because it's so trivial for super language like that?
Yeah, that happened.
Also remember the one time where the C/C++ LARPers couldn't do the same? I do and I also remember them moving the goalposts after the LISP fags posted their solutions.

Don't fall for their unsafe language, don't even associate with them. They are the worst cock suckers around, a real fucking disgrace to all programmers.

Nolan Cox
Nolan Cox

And so the LISPfag asspain begins anew.

Anthony Gutierrez
Anthony Gutierrez

Cnile LARPers can't even program a simple text editor
And so the evading begins anew.

Carson Evans
Carson Evans

these threads suck, stop posting in them. Also nice animu-girl, chomo.

Hudson Kelly
Hudson Kelly

LISPfags are still mad
LISPfags still haven't finished a simple text editor

Attached: 5e2f0e1b82e5ae3c96b1e5471c1098e4fc80409370b977265d321ec199d52f96.png (567.41 KB, 1120x1080)

Joshua Rogers
Joshua Rogers

You can rescind the GPL btw.
Also fuck white men for preventing me from marrying a cute loli.

Levi Perry
Levi Perry

Literally the best thread on tech

Lisp get fucked
SBCL get fucked
Clojure get fucked
Racket get fucked
S Expressions get fucked
MIT get fucked
Rudolf Winestock get fucked
Hacker Newsniggers get fucked
HipsterDevs get fucked

Anthony Brown
Anthony Brown

I thought they wrote one but it only took 6 whole months.

Attached: the-oomer-0-)ooo-lol-48703652.png (21.97 KB, 500x375)

Cameron Thomas
Cameron Thomas

what is emacs
Cniles are braindamaged to the point of retardation.

Kevin Sullivan
Kevin Sullivan

simple text editor

Attached: sagenegated.jpg (57.16 KB, 600x450)

Lincoln White
Lincoln White

moving the goalposts
it's the third thread
JOJ

Nolan Barnes
Nolan Barnes

he is STILL assmad enough to make these threads

Attached: 1460045804817.png (166.37 KB, 400x480)

Isaiah Evans
Isaiah Evans

1080200>>1080203

It was also supposed to be one made my LISP users, not one made twenty five years ago.

Attached: sage-negated.jpg (19.84 KB, 447x306)

Ethan Edwards
Ethan Edwards

goalpost moving intensifies

Aiden Cox
Aiden Cox

the graphical requirement was pretty lame, but rather than righteously flout that ("here's a vi-like editor for a terminal that someone might actually grow a practical editor out of, take it and fuck off"), someone posted a Racket solution that was a GUI text buffer editor with no features, not even file management.
Lisp confirmed terrible.
These threads are OK. Just post more code and less of the same sniping you can see someone already posted five times already.
Challenge #0: write an ed-style editor.
required tech:
1. command line args
2. reading/writing files
3. line-based replacement of file contents
4. interactive commands
minimal ed-like commands for those without culture. Feel free to make real ed commands instead:
1. 'p' to print out entire file content
2. '123 r blah blah blah' to replace line 123 with blah blah blah
3. 'w' to write file
4. 'w foo' to write to file foo
5. s/a/b/ to replace a with b in the entire file.
exhibit #0: open a file containing the following text and fix it with an ed session. You know what the problem is. No need to word wrap.Linux was originally developed for personal computers based
on the Intel x86 architecture, but has since been ported to
more platforms than any other operating system.[20] Linux is
the leading operating system on servers and other big iron
systems such as mainframe computers, and the only OS used on
TOP500 supercomputers (since November 2017, having gradually
eliminated all competitors).[21][22][23] It is used by
around 2.3 percent of desktop computers.[24][25] The
Chromebook, which runs the Linux kernel-based Chrome OS,
dominates the US K–12 education market and represents nearly
20 percent of sub-$300 notebook sales in the US.[26]

Linux also runs on embedded systems, i.e. devices whose
operating system is typically built into the firmware and is
highly tailored to the system. This includes routers,
automation controls, televisions,[27][28] digital video
recorders, video game consoles, and smartwatches.[29] Many
smartphones and tablet computers run Android and other Linux
derivatives.[30] Because of the dominance of Android on
smartphones, Linux has the largest installed base of all
general-purpose operating systems.[31]

Dylan Thomas
Dylan Thomas

still moving goal posts

Jack Stewart
Jack Stewart

it has to be completely featureless!
Well, I know LISP can't do much, but that's kind of pathetic...

Liam Jenkins
Liam Jenkins

it's a
new
goal post and it's numbered, so that later challenges can be easily distinguished from it.
meanwhile, "moving goalposts waaah" we've already got 5x the quota of in these threads. By my solemn of goalpost-moving, you are hereby required to complain about goalposts only in the context of a code solution to a numbered challenge, or to the original one.

Joseph Russell
Joseph Russell

what is emacs

moving the goalposts isn't enough anymore
let's create new ones
TOP
FUCKING
WEW
LAD

Lucas Sanchez
Lucas Sanchez

goalposts waaah
no code
red flag.
mods?
mods?

Dominic Clark
Dominic Clark

cnility

Evan Young
Evan Young

<There's no text editor in LISP
What about emacs?
<No, made entirely in LISP
What about zmacs?
<No, you need to make the text editor yourself
What about this one in racket?
<No, it doesn't have enough features
It was just a thread where the goal posts were continually moved over and over again. It eventually reached a point where no one wanted to waste time making an editor that would be discounted for some reason. When the task was asked for one to be made in C, they didn't even make an attempt.

David Sullivan
David Sullivan

1080226
doubleposting
Stop being a newfag but thanks for the bumps :^)

Brody Sanchez
Brody Sanchez

in the last thread someone got btfo when an user actually delivered. the best part is that he is still assblasted about it. also, why haven't you posted any actual criticism of lisp? instead of mindlessly creating new threads, why don't you actually prove that you know something you are talking about. because there could be a genuine (((reason))) why you didn't accept the text editor that user posted. you even seem to think that coding a text editor is an insanely difficult task. could it be that you are just a nocoder yourself? you can prove that you can code by programming a text editor in Rust.

Attached: 1562548851-1.jpg (85.83 KB, 555x681)

Noah Campbell
Noah Campbell

programming
computer science
Not technology

Elijah Foster
Elijah Foster

goalpost
moved

Jacob Diaz
Jacob Diaz

heh, what kind of pathetic reply is that? you aren't even trying.

Attached: kizuna-sigh.jpg (33.19 KB, 451x442)

Thomas Smith
Thomas Smith

I'm here for technology, not to try to program in rust

Dylan Hall
Dylan Hall

It wasn't a double post retard. The first post was deleted due to a typo, then I made a new post without the typo.

Carter Kelly
Carter Kelly

goalpost

goalpost

Dominic Wood
Dominic Wood

claims to be there for Zig Forums
<can't discuss or contribute anything
why do you then even make these threads? do you just want to shit up this board? are you pretending to be /intl/?

rust
well, write it in another language then.

Attached: 7fa94a44d73895eb1864.jpg (69.42 KB, 638x746)

Benjamin Williams
Benjamin Williams

silence

Josiah Watson
Josiah Watson

Lisp is the most Jewish programming language.

The Lisp programming language family was created and popularized by:
John McCarthy original Lisp creator, mother's name Glatt
Gerald Jay Sussman - Scheme
Sam Steingold - CLISP
Warren Teitelman - Interlisp
Richard Stallman - Emacs, Lisp, GPL, communist
Seymour Papert - Logo
Barbara Liskov
Joel Moses
Marvin Minsky
Alan Perlis
Frank Rosenblatt

Attached: clisp.png (88.61 KB, 455x326)

Adam Robinson
Adam Robinson

cool story bro

Colton Myers
Colton Myers

1080256
still not posting any real points
still not posting any code
last resort to muh (((jews)))
while it is true that it's important to check who is behind any given project/study/whatever, just saying something about kikes means nothing by itself. seriously, the last thread was going on for a long time, and yet you are still unable to provide any criticism at all. prove it that you actually know something about the subject. also, how does GPL has anything to do with lisp? the fact that you aren't posting anything of substance just proves that you don't even want to discuss anything.

Attached: Kizuna-Ai-God-You-are-Pathetic.jpg (72.75 KB, 1024x1024)

Matthew Bennett
Matthew Bennett

One was posted that failed to meet most of the requirements and used a pre-made framework. It couldn't even save the text to a file and they didn't compile it to a binary as per requirements. From then on the LISPfag claimed victory and anything pointing out that flaws in his shitty code was called goalpost moving. He even went so far as to slide the old thread off the catalog to hide his shame. Now he replied to every thread accusing everyone of being a LARPer when he couldn't even put together something simple in the dead language he constantly shills. He's the samefag that runs around calling everyone that posts something about *nix brain dead.

I was honestly let down because I wanted to see what he could do. It's no surprised he turned out to be the biggest LARPer of all and all his posts were pure projection. He's only slightly more tolerable than the Rusttrannys.

Attached: bc1bfb85614097b2731364dcb35f81e9e5b0f4475c5f1e9f83b33586ce032b4a.jpg (239.45 KB, 800x800)

Hudson Sanchez
Hudson Sanchez

going full damage control mode
you glow in the dark, pal. your little "challenge" was completed. i remember how you started kvetching because the text editor needed its runtime. but what you failed to realize was that this little comment revealed that you know very little about programming. even C needs its runtime Then whenever the thread was almost got pruned, you necrobumped the thread with more low-effort posts.

Attached: 87585c8dd30197e1fb0c33a1cff056513f6bcd5c5df7c70679e64224f50e179a.png (2.24 MB, 1584x1584)

Jayden Phillips
Jayden Phillips

every user that disagrees with me is the same person
If your code was so great then re-post it for all the anons to decide for themselves.
you won't

Easton Robinson
Easton Robinson

Lisp is, and will continue to be a toy language for academics and do-nothings. How long has MIT shilled lisp, scheme and racket? How long have those abominations failed to produce useful software? I ask you, if lisp is so powerful, where are the results? Where is the software? Nobody gives a fuck about the intellectual purity of the implementation of your language. Does the software solve my problem or not?

The lisper is immunized against all dangers: one may call him a scoundrel, parasite, swindler, profiteer, it all runs off him like water off a raincoat. But call him a lisper and you will be astonished at how he recoils, how injured he is, how he suddenly shrinks back: “I’ve been found out.”

Nathaniel Gray
Nathaniel Gray

Why don't you post your criticism of lisp (in general) or the text editor?
every user that disagrees with me is the same person
ironic.

<still not providing any criticism....
where are the results? Where is the software?
Emacsen, StumpWM and Light Table, for example. Clojure's site also has this list clojure.org/community/success_stories and I also found this list github.com/azzamsa/awesome-cl-software According to (((wikipedo))), Jak and Daxter and Crash Bandicoot were also programmed in a lisp called "GOAL" and it's predecessor "GOOL". Lisp was also used for scripting in The Last of Us (youtube.com/watch?v=Ox2H3kUQByo&t=37m40s) and Age of Empires 2 and Halo: Combat Evolved/Halo: Custom Edition (blamscript).
Does the software solve my problem or not?
yes because lisp supports all past and future paradigms of programming.

Attached: a1dd5e2a825b8c112dee26a352e612677a9e08421ec111ea0d46bfef37f2ee2e.gif (60.08 KB, 230x270)

Xavier Peterson
Xavier Peterson

But call him a lisper and you will be astonished at how he recoils
Zig Forums really needs to stop misusing this quote. Lispers do not fret at being called Lispers.

Logan Rivera
Logan Rivera

won't post his code
still butt blasted he couldn't meet the simple requirements
I'm not the faggot that sperged so hard I became 250+ replies to the original thread. Here are the requirements you failed to meet for reference. Before you claim I was the OP it's a copy of the picture he posted. I should go dig up the archived version of the thread for a good laugh. You were so butthurt you constantly came back to sperg any time someone bumped it. Stick to calling anons LARPers and posting 30 year old posts from mailing lists shitting on *nix. That's all you're good for.

Attached: lispfagscantcode.jpg (140.44 KB, 887x535)

Aaron Wood
Aaron Wood

Found the archive of the second thread for anyone that wants to see why the LISPfag is running so much damage control.

archive.is/oUEwA

Attached: LaughingGas.gif (694.84 KB, 500x281)

Josiah Foster
Josiah Foster

I love these threads. Lispnigger v. Anti-lispnigger drama always cracks me up. But yeah, Lisp is for faggots and pseudo-academic retards. Program in superior C/C++, the white man's language.

Attached: lispniggers-btfo.mp4 (8.17 MB, 1280x720)

Daniel Wood
Daniel Wood

why do you ignoring all points? also, why do you keep on madposting? are you butthurt, perhaps? well, congratulations, hothead, you got yourself caught. you are the only one who hasn't posted any reasons why lisp is bad. the user posted the editor in the last thread, and multiple anons pointed out both ITT and in the previous thread that both emacs and light table are programmed in lisp. why those editors don't count?

the only reason why you keep on madposting and doing damage control is that you aren't even interested in discussing anything.

Attached: Samefag-Matrix.jpg (174.9 KB, 1024x768)

Gavin Moore
Gavin Moore

Post your code, LISPfaggot.

Juan Ortiz
Juan Ortiz

It's in the archive I posted and no it doesn't meet all the requirements.

projection
everyone that disagrees is samefag
Guess how I know you're the faggot that sperged in the first two thread?

Attached: lispfagismad.png (256.65 KB, 1806x392)

Joseph Myers
Joseph Myers

you are the only one who hasn't posted any reasons why lisp is bad.
The point of the first two threads was for (((you))) to show why it's good. Instead you cried samefag, goalpost moving, and called everyone a LARPer without producing any code yourself.
the user posted the editor in the last thread
Which failed to meet the requirement of feature parity with notepad. It took some fag 3 months to produce a text box that couldn't even save data.
and multiple anons pointed out both ITT and in the previous thread that both emacs and light table are programmed in lisp. why those editors don't count?
Because the point of the thread was for (((you))) or any other faggot to produce a simple text editor in a language you constantly shill as simple and superior to everything else. The OP stated existing projects wouldn't be accepted. Instead of taking up his challenge you shit up two threads with your butthurt, slid them off the catalog, failed to produce something that met the requirements after several months, went on to state it was good enough and cried any time someone criticized the shitty code. A pajeet could have made something that met the requirements in javascript in an afternoon. You couldn't do it in 3 months in LISP.

I don't even care about retarded language wars but I enjoyed watching you fail just like I enjoyed watching you sperg every time I bumped the thread just to see if I could farm more replies out of you. So far you haven't disappointed.

Attached: 1458566683115.png (698.28 KB, 1280x720)

Jeremiah Ward
Jeremiah Ward

If you aren't programming in MATLAB you are probably a useless faggot not doing real computer science, instead mindlessly sucking cum from your fingers as you try to one-up others about your useless language.

99% of software engineers only create technology for literal, actual niggers to send pictures of their genitals to each other. You are pathetic sub-140 IQ faggots and I hate all of you.

Kevin Bennett
Kevin Bennett

you seem genuinely upset. You might want to mention it to your doctor. The HRT can have sometimes effects on the stability of your mood. Good luck.

Dylan Cooper
Dylan Cooper

no u

Jackson Miller
Jackson Miller

Nigger nigger nigger nigger nigger cring baste baste golpust

Stfu snf

Anthony Gomez
Anthony Gomez

can't afford mathematica?

Jason Garcia
Jason Garcia

:- module ed.
:- interface.
:- import_module io.
:- pred main(io::di, io::uo) is det.
:- implementation.
:- import_module list, string, maybe, bool, exception, int.

:- type editor
---> editor(
filename :: maybe(string),
file :: list(string)
).

:- pred load(editor, editor, io, io).
:- mode load(in, out, di, uo) is det.

:- pred write(editor, editor, io, io).
:- mode write(in, out, di, uo) is det.

:- pred print(editor, io, io).
:- mode print(in, di, uo) is det.

:- pred edit(int, string, list(string), list(string), list(string)).
:- mode edit(in, in, in, in, out) is det.

:- pred replace(string, string, editor, editor).
:- mode replace(in, in, in, out) is det.

:- pred ed(editor, io, io).
:- mode ed(in, di, uo) is det.

main(!IO) :-
io.command_line_arguments(Args, !IO),
( if Args = [Filename] then
some [!E] (
load(editor(yes(Filename), []), !:E, !IO),
ed(!.E, !IO)
)
else if Args = [] then
ed(editor(no, []), !IO)
else
io.progname_base("ed", Program, !IO),
io.format(io.stderr_stream, "usage: %s [<filename>]\n",
[s(Program)], !IO),
io.set_exit_status(1, !IO)
).

load(editor(no, _), _, !IO) :- throw(software_error("loaded without a filename")).
load(!.E @ editor(yes(Filename), _), !:E, !IO) :-
io.open_input(Filename, OpenRes, !IO),
(
OpenRes = ok(Stream),
read_lines(Stream, Lines, !IO),
!E^file := Lines
;
OpenRes = error(Error),
warn_open(Filename, "input", io.error_message(Error), !IO)
).

write(editor(no, _), _, !IO) :- throw(software_error("write without a filename")).
write(!.E @ editor(yes(Filename), _), !:E, !IO) :-
io.open_output(Filename, OpenRes, !IO),
(
OpenRes = ok(Stream),
foldl(io.write_string(Stream), !.E^file, !IO),
io.close_output(Stream, !IO)
;
OpenRes = error(Error),
warn_open(Filename, "output", io.error_message(Error), !IO)
).

print(editor(_, Lines), !IO) :-
foldl(io.write_string, Lines, !IO).

edit(LineNo, Line, Pre, [], L) :-
( if LineNo =< 0 then
list.reverse([Line | Pre], L)
else
edit(LineNo - 1, Line, ["\n" | Pre], [], L)
).
edit(LineNo, Line, Pre, [H | Post], L) :-
( if LineNo =< 0 then
L = list.reverse(Pre) ++ [Line | Post]
else
edit(LineNo - 1, Line, [H | Pre], Post, L)
).

replace(From, To, !E) :-
foldl((pred(!.Line::in, Acc::in, [!:Line | Acc]::out) is det :-
string.replace_all(!.Line, From, To, !:Line)
), !.E^file, [], Lines),
!E^file := list.reverse(Lines).

ed(!.E, !IO) :-
io.read_line_as_string(Res, !IO),
(
Res = ok(String),
Line = chomp(String),
Cmd = split_at_separator((pred(' '::in) is semidet), Line),
( if Cmd = ["p"] then
ed.print(!.E, !IO)
else if Cmd = [NStr, "r" | Replace], to_int(NStr, N) then
edit(N, join_list(" ", Replace) ++ "\n", [], !.E^file, Lines),
!E^file := Lines
else if Cmd = ["w"] then
write(!E, !IO)
else if
index(Line, 1, Sep),
["s", From, To, ""] =
split_at_separator((pred(C::in) is semidet :- C = Sep), Line)
then
ed.replace(From, To, !E)
else
io.print(Cmd, !IO),
io.write_string(io.stderr_stream, "?\n", !IO)
),
ed(!.E, !IO)
;
Res = eof
;
Res = error(E),
io.format(io.stderr_stream, "got error reading editor command: %s\n",
[s(io.error_message(E))], !IO)
).

:- pred read_lines(io.text_input_stream, list(string), io, io).
:- mode read_lines(in, out, di, uo) is det.
read_lines(Stream, !:L, !IO) :-
read_lines(Stream, [], !:L, !IO),
list.reverse(!L).

:- pred read_lines(io.text_input_stream, list(string), list(string), io, io).
:- mode read_lines(in, in, out, di, uo) is det.
read_lines(Stream, !L, !IO) :-
io.read_line_as_string(Stream, Res, !IO),
(
Res = eof,
io.close_input(Stream, !IO)
;
Res = ok(Line),
read_lines(Stream, [Line | !.L], !:L, !IO)
;
Res = error(_),
throw(Res)
).

:- pred warn_open(string, string, string, io, io).
:- mode warn_open(in, in, in, di, uo) is det.
warn_open(Filename, Use, Reason, !IO) :-
io.format(io.stderr_stream, "failed to open %s for %s: %s\n",
[s(Filename), s(Use), s(Reason)], !IO).

Noah Gutierrez
Noah Gutierrez

as used for the task:$ wc -l linux.txt ; grep -c Linux linux.txt ; grep -c GNU/Linux linux.txt
21 linux.txt
6
0
$ ./ed linux.txt
25 r --end--
s,Linux,GNU/Linux,
w
$ wc -l linux.txt ; grep -c Linux linux.txt ; grep -c GNU/Linux linux.txt
26 linux.txt
6
6

Gavin Mitchell
Gavin Mitchell

goal posts were continually moved
No they weren’t. The OP of those threads had a clear set of requirements that weren’t met. What’s your goal, revisionist?

John Brooks
John Brooks

At least someone posted code. I'll run it tomorrow to see how well it works. It's good to see a few anons are still around that want to actually discuss Zig Forums. The board has really gone to shit over the years. The tripfags were bad and they just became worse after their precious trips were taken away. I'm pretty sure they're the ines that constantly derail every thread in some lame attempt to get revenge. The BO is hands off and too busy namefagging on IRC to give any fucks about what goes on here.

Connor Clark
Connor Clark

LOL is this Erlang or some other Prolog variant?

Jace Richardson
Jace Richardson

The board has gone to shit because of threads like this and LARPers like you.

Elijah Wilson
Elijah Wilson

Mercury. It's like a purely functional prolog.
The ed-like challenge is easy. There's still no Lisp candidate for it? Instead you went and made a thread asking for non-Lisp code? Are you really even a fan of the language?

Julian Stewart
Julian Stewart

Oh boy that was like the first thing lispfags tried to shill as their solution, too bad much of its codebase is in C.

They could make it glorious and gigantic for all I care but they can't even make a simple one so they were given guidelines they could focus on.

Assmad over what? Over utter incompetence of people thinking they are super hackers with magic super language? But I'm not one of them.

I think even that is irrelevant, but nothing really exists. They tried to offer that Climacs editor as ancient solution ("development" had started like 20 years ago), but turned out it didn't even compile and and its git commit history was absolutely hilarious, it was some European professors eternity project to (I assume) get his salary so it was more important he commits anything often than make it work and usable.

I agree, then again it's easy to forget when looking at simple notepad.exe that there are actually super hackers in this world who can't replicate that in one lifetime using super magic language Lisp.

Emacs was never 100% Lisp no matter how much you scream otherwise, anyone can check its sources, and Zmacs is ancient software that doesn't run and thus doesn't fulfill basic requirement of run and compile has to be verifiable. Zmacs cope is pretty much equivalent to we wuz kangz cope, nevermind how retarded and incompetent we are now, we used to have this cool wall painting 5000 years ago look look.

why haven't you posted any actual criticism of lisp?
These threads are better criticism of it than anyone could ever write, proof is in the pudding. You are owning yourselves with every single post you make. That it turned out like this is nobody's fault but yours. It all started with a simple innocent question, don't forget that. Rest is all on you.

This. It was equivalent of making text box in HTML and saying "now imma real JavaScript pro"

Nice! I have the first one: archive.fo/mnbNo
"You have absolutely no clue how Lisp works." makes me lmao every time.

you seem genuinely upset
This is just sad projecting holy shit.

To be fair those set requirements came later, but they were made because there was no end to their desperate slide attempts, nervous hand-wringing and sweaty kvetching.

Attached: 1537411449337.jpg (90.67 KB, 640x932)

Parker Fisher
Parker Fisher

(defun file-to-lines (file)
(let ((line (read-line file nil)))
(if (null line)
nil
(cons line (file-to-lines file)))))

(defun find-and-replace (string find replace)
(let ((found (search find string)))
(if (null found)
string
(concatenate 'string
(subseq string 0 found)
replace
(find-and-replace (subseq string (+ found (length find))) find replace)))))

(defun ed-print (lines)
(map nil
(lambda (line)
(format t "~d~%" line))
lines))

(defun ed-replace (lines n line)
(if (< (length lines) n)
nil
(setf (aref lines (1- n)) line)))

(defun ed-write (lines name)
(with-open-file (file name :direction :output :if-exists :supersede)
(map nil (lambda (line)
(write-line line file))
lines)))

(defun ed-find-and-replace (lines find replace)
(map-into lines
(lambda (line)
(find-and-replace line find replace))
lines))

(defun ed-is-print (input)
(string-equal input "p"))

(defun ed-is-replace (input)
(let ((split (search " r " input)))
(and (not (null split))
(not (null (parse-integer (subseq input 0 split) :junk-allowed t))))))

(defun ed-is-write (input)
(let ((size (length input)))
(and (>= size 0)
(eq (char input 0) #\w)
(not (eq size 2))
(or (eq size 1)
(eq (char input 1) #\space)))))

(defun ed-is-find-and-replace (input)
(let ((size (length input)))
(and
(>= size 5)
(eq (char input 0) #\s)
(eq (char input 1) #\/)
(not (null (find #\/ (subseq input 3 (1- size)))))
(eq (char input (1- size)) #\/))))

(defun ed-parse-replace (input)
(let ((split (search " r " input)))
`(,(parse-integer (subseq input 0 split) :junk-allowed t) ,(subseq input (+ split 3)))))

(defun ed-parse-write (input def)
(if (eq (length input) 1)
def
(subseq input 2)))

(defun ed-parse-find-and-replace (input)
(let ((split (+ (position #\/ (subseq input 2)) 2)))
`(,(subseq input 2 split) ,(subseq input (1+ split) (1- (length input))))))

(defun ed-repl (lines name)
(let ((input (read-line *standard-input* nil)))
(if (null input)
nil
(progn
(cond
((ed-is-print input)
(ed-print lines))
((ed-is-replace input)
(apply #'ed-replace (cons lines (ed-parse-replace input))))
((ed-is-write input)
(ed-write lines (ed-parse-write input name)))
((ed-is-find-and-replace input)
(apply #'ed-find-and-replace (cons lines (ed-parse-find-and-replace input)))))
(ed-repl lines name)))))

(defun ed-start (name)
(let ((file (open name :if-does-not-exist nil)))
(if (null file)
(ed-repl (make-array 0) name)
(let* ((lines-list (file-to-lines file))
(lines (make-array (length lines-list) :initial-contents lines-list)))
(close file)
(ed-repl lines name)))))

(defun main ()
(let ((args (or #+CLISP *args*
#+SBCL *posix-argv*
#+LISPWORKS system:*line-arguments-list*
#+CMU extensions:*command-line-words*
nil)))
(if (null args)
(format t "~d~%" "Your implementation of Common Lisp is not supported")
(ed-start (cadr args)))))

Samuel Thompson
Samuel Thompson

Maybe lispfags just need very simple instructions to follow. How about this pic related? You can do it, come on little buddies.

Attached: COLTE---Copy.png (16.74 KB, 575x396)

Isaiah Cooper
Isaiah Cooper

i just dont get it

Nathan Peterson
Nathan Peterson

You missing out on the best on-going cringe show on the web bro, here
Ep.1: archive.fo/mnbNo
Ep.2: archive.is/oUEwA

Jordan Green
Jordan Green

It took some fag 3 months to produce a text box
How delusional are you? Do you really think that someone still takes (((you))) seriously. You have proven countless times that you don't even know why you hate lisp. Also, the challenge was completed in previous thread and you lost. Actually it was completed long before you even posted it, since emacs exists

reee emacs was never 100% lisp
Yes it is. The only thing that is in C is the kernel. But I guess you will ignore that too. I wonder if the unixhater was right all along and Unix really causes braindamage.

Bentley Peterson
Bentley Peterson

Unix really causes braindamage
UNIX *is* braindamage

Matthew Flores
Matthew Flores

this works to replace Linux with GNU/Linux in the test file btw, surprisingly. s/Linux/GNU/Linux/ does the job. If you install SBCL you can try it out with: sbcl --load ed.lisp --eval '(main)' linux.txt
Speaking of s///, the code for this in Mercury vs. CL makes a nice point of comparison. On the one hand Mercury's lambda looks hairy af; on the other hand CL works so much harder to recognize and then parse the line that it's silly. Mercury does the recognition and parsing in one step, index(Line, 1, Sep),
["s", From, To, ""] =
split_at_separator((pred(C::in) is semidet :- C = Sep), Line)
whereas just recognition in CL is already(defun ed-is-find-and-replace (input)
(let ((size (length input)))
(and
(>= size 5)
(eq (char input 0) #\s)
(eq (char input 1) #\/)
(not (null (find #\/ (subseq input 3 (1- size)))))
(eq (char input (1- size)) #\/))))

the point ofc isn't to perfectly implement the minimal ed-like editor. The point is implement version 0.0.0 of a useful vi-like editor. And CL's now done that. You can grow from here, implement ex, slap on a visual mode...
of course the real growing pains will be in changing data structures as you get serious about editing big files. I'd rather change data structures with a strictly typed language that had my back. Getting thrown into the Lisp debugger isn't all it's cracked up to be.

Luke Long
Luke Long

improved: index(Line, 1, Sep),
["s", From, To, ""] = split_at_separator(unify(Sep), Line)

Isaac Robinson
Isaac Robinson

Common Lisp is strictly typed. You mean static rather than dynamic.

Noah Mitchell
Noah Mitchell

emacs is 100% lisp except for that part which actually makes it run which is C so it's 100% lisp lol
the absolute state of lispfags jesus christ, this isn't even retarded anymore, this is pure mental illness

Levi Phillips
Levi Phillips

nice madpost

Elijah Anderson
Elijah Anderson

Dude, you are claiming that a program that has its core part made in C is still somehow 100% Lisp. That is literally insane.

Jayden Perry
Jayden Perry

I'm not sure what's more pathetic. That he's been pretending to be retarded for month after month or that he's not and is genuinely this delusional. I almost wonder if fags are trying to ape Terry's behavior for attention or to fit in.

Oliver Cook
Oliver Cook

Misreplied, meant to reply to

Elijah Roberts
Elijah Roberts

gj user. I was half-way through writing my scheme version.

vi-like editor
What's more important is someone giving it a GUI.

Justin Gonzalez
Justin Gonzalez

if Emacs were a painting that you put up on a wall to admire, then the C part would indeed be a big problem. It'd be like graffiti, or a splotch from someone spilling a chemical on the painting.
But Emacs is a program and programs move. If you care deeply about Emacs and want it improve it, you'll pretty never touch C. Your problem is never going to be related to the C. You're never going to troubleshoot into the C. So for practical purposes it doesn't matter in the slightest. The reality of hacking Emacs is that you're hacking Lisp.
giving an editor a GUI
save that for when you reimplement krita or inkscape or something.

Jaxson Watson
Jaxson Watson

you need a GUI for paint
No you don't. Terminal paints are fine. It's a perfect match of block to pixel. Also it's the Unix way. I can easily run paint from my terminal whenever I want instead of having to call a program and then wait for it to load, enjoy your bloat. Oh wait are you too much of a pleb to paint in the terminal lmao go back to Ubuntu nub.

Cooper Barnes
Cooper Barnes

If you care deeply about Emacs and want it improve it, you'll pretty never touch C.
Hahaha what a fucking lie. Yeah, I'm sure to port Emacs to X11 and add image support you didn't have to modify the C part.

Henry Price
Henry Price

You don't. All you have to do is insert the X11 calls to the graphical output of Emacs. The C kernel of Emacs doesn't deal with that.

Jaxson Bennett
Jaxson Bennett

What the hell is this terryposting? After failing to convince sane people that program with its core part in C is in fact 100% Lisp anyways, you start rambling complete nonsense.

Charles Jenkins
Charles Jenkins

the LISP fags
plural
lel.

Adam Russell
Adam Russell

grrr there are so many posts calling me a moron
clearly this is the work of my eternal nemesis, the lispfag! he made all of them!
but i won't let him get away with this! i will defend the glory of c and EXPOSE his lies! the forum of Zig Forums will finally see the truth!
literal braindamage

Jonathan Reed
Jonathan Reed

It's funny that you never post code or original thoughts. You just call other people LARPer and post 30 year old mailing list posts. You're the cancer.

Grayson Jenkins
Grayson Jenkins

you never post code
You also never post code

James Peterson
James Peterson

I remember the thread where the lispfag posted his editor. Everyone made fun of him because it was large as fuck, like 10mb or so and was extremely slow, 1mb txt file would freeze it. I remember I posted my 5 minute effort made in autoit (BASIC kind of language) that together with the interpreter was below 0.5mb and didn't have a problem with large text files. Lispfag didn't respond to this as far as I remember, so don't say nobody posted their own editor in the thread...

Carson Lopez
Carson Lopez

"Lispfag" that made shalompad here. Funny thing is that was my first program written in racket or any kind of lisp language. It was literally copy and paste from documentation, I actually kinda liked it how easy it was to make GUIs. The editor did everything OP asked for, but then the goalposts started moving, muh not all notepad features were implemented, muh bloat, muh freezes. It's a pointless task to complete. This was all just shitposting.

Liam Parker
Liam Parker

give me x
<here's y
that's not x
<wow you're never fucking happy are you

Blake Ross
Blake Ross

copy and paste a Racket editor from Racket documentation
it's not very good
don't try to improve it
you've satisfied Lisp's honor by not being willing to maintain a Lisp project

Chase Foster
Chase Foster

give me x
<gives 80% of x with explanation why it's pointless spending a day for other 20%
but muh 100% of x
<whatever faggot, go suck a dick
noooo, you can't do this to me, go back to work and add binary compatibility with Windows 95 ABI
<doesn't do it because waste of time
lol lisp sucks
<
hello, I said that lisp sucks
<
Several months later...
Lisp-homos can't do anything with their shit language

Dylan Flores
Dylan Flores

80% of x
<what's wrong, it's 80% of a car why aren't you happy?

Camden Stewart
Camden Stewart

It was nowhere near 80%. That Racket thing was equivalent to HTML text box in a browser.

then the goalposts started moving
You posted it after goalposts were set and nobody moved them but asked you to keep developing it to reach goalposts, at which point you threw autistic fit that continues to this point. But it did reveal how shit Racket is in a way for requiring that entire fucking system to run anything, what was it, 300MB install, and people are looking forward to usable application they can just run, it was in goals. You did good otherwise and your attempt proved very educational (just didn't prove anything positive about Racket). Keep trying buddy.

Attached: 1523040788433.jpg (29.28 KB, 368x535)

Jose Turner
Jose Turner

what's wrong, it's 80% of a car why aren't you happy you got that for free? You'll have to pay mechanic to replace that windshield and put on a new set of wheels, but that's only 20% of the car so it shouldn't be a problem for you.

Brayden Green
Brayden Green

oy vey you should be thanking me for giving you the chassis of a car to put wheels on and an engine into!

Charles Reed
Charles Reed

It was nowhere near 80%. That Racket thing was equivalent to HTML text box in a browser.
It could open, modify and save local files. That's somehow equivalent to HTML text box in a browser?
300MB install, and people are looking forward to usable application they can just run
That was solved once I figured out how to use their packaging tool, but you started sperging out about search functionality being just a placeholder item in the menu.
Keep trying buddy.
Still butthurt after so much time has already passed. We've solved your soydev challenge, nobody is going to waste time pleasing a sperg on the internet.

Andrew Myers
Andrew Myers

nobody is going to waste time pleasing a sperg on the internet
Yet you keep trying. Do you have daddy issues?

Attached: smug-(285).jpg (74.24 KB, 328x285)

John Reed
John Reed

I'm just here for the (You)'s.

Camden Mitchell
Camden Mitchell

Did you actually develop it further? Post sources, instructions to build it and executable. I'll take a look.

Xavier Mitchell
Xavier Mitchell

No, but the source should be in the original thread, I don't have the files anymore.

Kayden Carter
Kayden Carter

You missing out on the best on-going cringe show on the web bro
Go back to cuckchan nigger

Charles Williams
Charles Williams

(defun ed-replace (lines n line)
(if (or (> n (length lines))
(<= n 0))
nil
(setf (aref lines (1- n)) line)))
(defun main ()
(let ((args (or #+CLISP *args*
#+SBCL *posix-argv*
#+LISPWORKS system:*line-arguments-list*
#+CMU extensions:*command-line-words*
nil)))
(cond
((null args) (format t "~d~%" "Your implementation of Common Lisp is not supported"))
((< (length args) 2) (format t "~d~%" "ed <name>"))
(t (ed-start (cadr args))))))

This will make it error if you do not pass a file and that it will no longer error trying to replace line 0 or below.
Yeah, Mercury has much better string processing functions in the standard library. Common Lisp has barely anything. Also pattern matching is awesome and Common Lisp is stuck in the past by not having it.

Evan Evans
Evan Evans

The minimal string handling is pretty bad, yeah. There's CL-PPCRE, but even though it optimizes literal regexes pretty well it still feels too heavy for most simple things. There are definitely libraries for pattern matching, but I don't have them memorized.

Eli Gonzalez
Eli Gonzalez

Oh come on, lispfag. We all know you're NEET and spend all day on Zig Forums defending your gay jewish language. No one is going to employ you to write it; and actually writing code is the antithesis of the lispfag, because every program written risks popping the delicate bubble of delusion that permits him to keep claiming the "superiority" of his language. So what else are you going to do besides bum around and shitpost here?
Perhaps the funniest revelation in this thread is that the "lispfag" that wrote shalompad isn't even a lispfag. That's probably why he was productive enough to actually do something. He had no skin in the game if it failed.

Brody Collins
Brody Collins

This entire avatar shitposting is stupid.
Why would we waste our time writing something that's already written in C? There are tons of text editors out there and one of them - emacs has even a huge part written in LISP, I'll better spend my time making something productive like, for example helping Guix System grow - isn't a functional package manager and a distribution built on Scheme - it's a good enough proof LISP isn't useless.
Saying that emacs doesn't count, because its core is written in C is like saying that being a web developer isn't about writing in HTML, CSS and JS, because "oh my! Its core is written in C, so you have to know C to make changes!", even if yes, the JS part is so big, people actually write shitty web 'apps' entirely on it, while touching no C at all.
And saying LISP is a bad language just because not many programs are written in it, it is not popular, etc. is a bad argument. C is popular today thanks to many historical factors, which are not necessarily C being so good. Microsoft Windows is dominant today and I don't think that's because of its quality.
Both C and LISP have advantages and making shitty avatarfag posts won't change it. I actually started learning Scheme thanks to those shitstorms about LISP sucking. It is actually a good language, in my opinion designed better than for example C++ I learned too. It has a cool, minimal, consistent and extensible (through macros) syntax and has a good type handling, even though variables in LISP are just boxes holding data and its type, it's at least a better type handling than in JS - you cant just do (string-append "this is a number: " 123), you have to convert it first (string-append "this is a number: " (string->number 123)). You also don't have stack overflows while doing simple tasks like iterating over an array or using recursive procedures. These features make Scheme, or at least GNU Guile a language in which you can write pretty stable and safe programs easily.
Also last time I checked GNU Shepherd - a replacement for Unix init written entirely in Scheme, actually boots or turns off my system faster than sysVinit written in C.
I've just started learning Scheme, but maybe if I won't have anything better to do, I'll write that text editor for you. Of course without Windows or OSX binaries, because Guile isn't ported to Windows (yet?), it would run on OSX, because it runs on FreeBSD, but anyway I don't want to waste my time providing support for proprietary operating systems. If you really care about being able to run Guile on OSX, just install it, and no it's no different from a C program having to have libraries as dependencies.
Guile's performance isn't bad either - it is constantly getting better
wingolog.org/archives/2019/06/26/fibs-lies-and-benchmarks

And Kizuna sucks, it's not a real AI and it's hosted on youtube, which is obviously botnet, but you probably post her pictures just to make people mad.

Attached: dynamic-languages.png (29.1 KB, 1173x869)

Samuel Hernandez
Samuel Hernandez

saying LISP is a bad language just because not many programs are written in it, it is not popular, etc. is a bad argument
This criticism is a holistic criticism aimed at both Lisp and especially Lisp community who go around sperging out declaring superiority with nothing to show for it. Also Lisp is shockingly popular (TIOBE screencap ITT) considering zero flagship applications it has to showcase. People who actually get hired to write it don't seem to write their own things for fun and showcase. It's old language with fanatic proponents especially among big name FOSS hackers like Stallman and Zawinski, so something smells here, where are the FOSS programs for starters, they had a experience and proficiency headstart in making those with their super magic language already in early GNU days but didn't. It's this total discrepancy between words and deeds that's the issue here. Resident lispfags only made this clearly visible. So spare us your stale theoretical rhetoric how it's so wonderful (on paper).

Carson Ward
Carson Ward

lol, write something useful if you want, that would be even better. People asked for a text editor because that's something you can do in one afternoon.

Justin Anderson
Justin Anderson

This criticism is a holistic criticism aimed at both Lisp and especially Lisp community who go around sperging out declaring superiority with nothing to show for it. Also Lisp is shockingly popular (TIOBE screencap ITT) considering zero flagship applications it has to showcase.
nothing to show
zero flagship applications
I listed some things in my previous post, but you don't seem to care about it.
Guile itself is an extension language - you can extend your C programs with it:
gnu.org/software/guile/
Guix and Guix System:
guix.gnu.org/
GNU Mes - GNU/Linux bootstrapping:
gnu.org/software/mes/
GNU Artanis - a framework for creating web applications:
web-artanis.com/
There are websites running on Guile http and Artanis, handling big traffic every day:
guix.gnu.org/
gnu.org/software/guile/
GNU Shepherd - a replacement for sysVinit
gnu.org/software/shepherd/

These examples show LISP is suitable for many use cases. Also take into account initially Scheme had been planned as a language for extending websites (so it was considered as good enough), but then came Oracle and told to Netscape, they wanted Java, and instead of Scheme, we have a language designed only in 10 days - JavaScript - a historical accident.

Evan Miller
Evan Miller

helping Guix System grow
Despite my low opinion of the Lisp community generally, I would like to see GuixSD succeed.

Jonathan Thompson
Jonathan Thompson

Crash & burn, lispfag.

Nicholas Reyes
Nicholas Reyes

This entire avatar shitposting is stupid.
<why are people using images on an imageboard?

Bentley Jackson
Bentley Jackson

why are people using images on an imageboard?
8ch.net/faq.html
<An imageboard lets you post text and images anonymously (without a name) about any topic - or no topic at all.
Also
<Users are not required to have names and, thus, feel no reason to build up an identity or reputation for themselves - posts are judged based on their content rather than who made them;
The keyword here is anonymously. Avatarfagging is the opposite of being anonymous, because you link your identity to an avatar. If imageboards were about having avatars, they would be called avatarboards.

Bentley Roberts
Bentley Roberts

It's been a year and OP couldn't submit his year-ass-long assignment and failed his elective course.
Heh

Easton Anderson
Easton Anderson

inb4 baphomet lispers doxx you instead

Kayden Diaz
Kayden Diaz

The keyword here is anonymously. Avatarfagging is the opposite of being anonymous
literally anyone can copy the avatar and pretend to be the speaker. If they do it well enough, this may go completely unnoticed, and without objections from the real speaker.
A masquerade isn't the same thing as an anonymous venue, but it's not the opposite of an anonymous venue.

Luke Williams
Luke Williams

Nice slide attempt asshole, "boohoo everyone who use same brand clothing are same named person boohoo" no fuck you and fuck off

Attached: 6ffb9183d8160.png (241.74 KB, 808x472)

Elijah Price
Elijah Price

And reveal the world what? That "this person undeniably revealed that we the Lisp community have absolutely nothing to show for our claim of superiority by asking us a question"? I'm looking forward to baphomet doxxing everyone of us, that's just a bonus in CV.

Daniel Butler
Daniel Butler

Remember the one time Common Lisp users were asked to make a simple text editor 100% with it and post runnable binary and sources, and they promptly used their magic language to deliver within a few posts because it's so trivial for super language like that?
Unironically yes, I do remember that. It's a shame you don't, and a shame I didn't archive it, so that you can quit your contrived bullshit and homo anime avatar-posting, you tranny faggot you.

Christian Bailey
Christian Bailey

GeneraOS? Symbolics custom made keyboards with up to 5000 or so inputtable glyphs? Lisp Machines? ELIZA?
Where are all these guys who literally made the Lisp OSes and computers? Dead??

Jordan Price
Jordan Price

Posting in a similar manner is breaking anonymity
UNIX-hater repeating the same quotes over and over, clearly identifying himself is okay
Fag that posts nothing but "lol cnilles" trying to force it, clearly identifying himself is okay
Fags using limited vocabulary along with slow activity means you can very clearly distinguish certain specific posters across multiple threads by how and when they respond, that's okay too
But posting anime pictures is going too far!

Isaiah Jenkins
Isaiah Jenkins

Others did archiving so your desperate lying has no effect

Oliver Brown
Oliver Brown

Posting bunch of utterly failed products from three decades ago and considering them peak achievement just proves what everyone is saying about Lisp and lispfags.

James Price
James Price

That's the bandwagon fallacy. History is littered with inventions that are technically better than other inventions but also fail to succeed in the marketplace.

Ethan Brooks
Ethan Brooks

triggered cnile spotted
unbased btw

Nolan Martinez
Nolan Martinez

everybody who uses $MEME is $PERSON_I_HATE avatarfagging
nice paranoid delusions, i.e. literal braindamage

Nathaniel Parker
Nathaniel Parker

failed
Well, at least the products are greater technical achievements than "hurr durr make a gui text editor".

Michael Garcia
Michael Garcia

samefagging this obviously

Jose Hall
Jose Hall

Lisp Machines
Oh, you mean these computers which had more latency than the roundtrip time around the world? Yeah, if the Internet was built with routers running on lisp you could send a packet to China and have it arrive there in about 5 minutes. Maybe.

Jace Torres
Jace Torres

Your identity is made of puzzles - using Kizuna's pictures is one of them and you're clearly not being more anonymous by doing so. If Kizuna was the default picture posted by everyone, like "Anonymous" with every post, it would be fine.
"boohoo everyone who use same brand clothing are same named person boohoo"
Knowing someone uses certain brand of clothing is actually a valuable information and it narrows down the set of people you're looking for. Also using an avatar changes the way people see you - almost always when I see Kizuna's face on Zig Forums it is connected to someone saying LISP is stupid and useless - thats building identity, imageboards are not about building identity.

Attached: avatarfags.png (32.42 KB, 1000x1000)

Dominic Ross
Dominic Ross

There it is. Episode 2, post >>952496
/thread

Nolan Wood
Nolan Wood

By identifying yourself as an user on Zig Forums you are no longer anonymous. Checkmate.

Brandon Phillips
Brandon Phillips

posting on an anonymous imageboard is a form of divination.
Divination is an evil practice, forbidden for Christians, which connects oneself to the realm of demons.
Sometimes you can tell who the demons are. But is that really what's important? At the end of the day they're all demons.

Aiden Edwards
Aiden Edwards

It doesn't have all of Notepad's features. Doesn't allow you to paste current time and date by pressing a button, nor does it allow you to load and save UTF-16 files.

Matthew Morris
Matthew Morris

Lol, just ran it on my computer and it works. I'll add the "Save" feature now.

Jack Gray
Jack Gray

I'll add the "Save" feature now.
As I promised. You can help me push the development further if you want.

Shalompad 0.1.1 "I don't even know Racket, because I usually use Guile"
In this release:
- better formatting by Emacs
- Save option knowing what file you're editing now

#lang racket/gui

(display "start")
(newline)

(define frame (new frame% [label "Shalompad - Ver 0.1.1 (I don't even know Racket, because I usually use Guile)"] [width 640] [height 480]))
(define editor-canvas (new editor-canvas%
(parent frame)
(label "Editor Canvas")))

(define text (new text%))
(send editor-canvas set-editor text)

(define menu-bar (new menu-bar%
(parent frame)))

(define file-menu (new menu%
(label "&File")
(parent menu-bar)))

(define edit-menu (new menu%
(label "&Edit")
(parent menu-bar)))

(define search-menu (new menu%
(label "&Search")
(parent menu-bar)))

(define help-menu (new menu%
(label "&Help")
(parent menu-bar)))

(define currently-edited-file "")

(new menu-item%
(label "Open")
(parent file-menu)
(callback (lambda (item event)
(define file (get-file))
(if file
(let ()
(define in (open-input-file file))
(send text insert (port->string in))
(set! currently-edited-file file)
(close-input-port in))
#f))))

(new menu-item%
(label "Save")
(parent file-menu)
(callback (lambda (item event)
(define file currently-edited-file)
(if (not (eqv? file ""))
(let ()
(define out (open-output-file file #:mode 'binary #:exists 'replace))
(display (send text get-text) out)
(close-output-port out))
#f
))))

(new menu-item%
(label "Save As...")
(parent file-menu)
(callback (lambda (item event)
(define file (put-file))
(if file
(let ()
(define out (open-output-file file #:mode 'binary #:exists 'replace))
(display (send text get-text) out)
(set! currently-edited-file file)
(close-output-port out))
#f
))))

(new separator-menu-item% (parent file-menu))
(new menu-item%
(label "Oy Vey, shut it down!")
(parent file-menu)
(callback (lambda (item event)
(exit)
)))

(send frame show #t)
[/code]

David Edwards
David Edwards

Did you paint that epik doxxxx with lisp program?

Josiah Williams
Josiah Williams

muh fallacy
Nope because those failed products left no legacy whatsoever. Nobody saw anything worthy pursuing that same path again to this day.

And dogshit on street has bigger complexity than a kitchen knife but you don't want that shit in your kitchen while you need knife every day.

Camden Taylor
Camden Taylor

Remember the one time Common Lisp...
Hey you, faggot OP, I've just found something better than a text editor, extensible in LISP and written in LISP without C at all - a browser written in Common Lisp.
<Common Lisp 93.9% Scheme 4.0% Makefile 2.1%
github.com/atlas-engineer/next
Eat shit and die.

John James
John James

Why don't you use Guile then? It's so popular that I'm sure more people will help with this editor.

Henry Martin
Henry Martin

So post links to the program.

Sebastian Brooks
Sebastian Brooks

without C at all
is a Webkit frontend
Nice. Here, I wrote a web browser in Python:

import browser
browser.run()

Parker Green
Parker Green

That's still the bandwagon fallacy.

Hunter Johnson
Hunter Johnson

Haha. Lispfags are so lame.

Jose Flores
Jose Flores

is a Webkit frontend
Oh, so here's the catch, anyway it seems to have some useful features excessing features of a basic text editor and showing LISP isn't useless by that.

Why don't you use Guile then? It's so popular that I'm sure more people will help with this editor.
Guile has only partial support for gtk2 today, whereas gtk3 is not supported at all. They're writing a program for translating gnulib objects to Scheme, which will make it possible to make bindings for both gtk2 and gtk3 automatically, but the software is in alpha stage now, so the only thing I could do is a cli text editor.

Cooper Watson
Cooper Watson

blah blah blah bullshit some more bullshit
Oh yeah? Let's search for "X11" in the source code and see what pops up.
github.com/emacs-mirror/emacs/search?utf8=✓&q=X11&type=
My oh my, what is that? 48 C files vs 25 Elisp files? Boy, that sure is embarassing for you.

Camden Russell
Camden Russell

Hmm. I like the on-page navigation hotkeys. But too bad it uses WebKit and doesn't even have its own API to communicate with it, using PyQtWebEngine which also renders the window in Qt. It's a toy program.

Colton Kelly
Colton Kelly

That's why there's the word fagging right next to avatar.

Ryder Moore
Ryder Moore

freetards have to do some seriously talmudic software development to first circumvent their own retarded license and then make actualy software
top kek

Leo Fisher
Leo Fisher

No.

Evan Hill
Evan Hill

freetards have to do some seriously talmudic software development to first circumvent their own retarded license and then make actualy software
What? You don't even understand what's going on here. Circumvent what?
If you confuse gtk+ (Gimp Tool Kit +) with the GPL (General Public License) you absolutely shouldn't talk about things you don't understand. Gtk+ uses gnulib to make it easy to make bindings for different programming languages:
gtk.org/language-bindings.php
The thing that'll make creating bindings for gtk+ automatically is guile-gi
github.com/spk121/guile-gi
It has nothing to do with license.
Also
<freetard
having freedom
being a retard
Pick one slave.

Lucas Lopez
Lucas Lopez

My bad I misread gtk as gpl. Also

having freedom
That's Stallman's definition of freedom and even so it doesn't mean freedom for developers but for source code.

Elijah Taylor
Elijah Taylor

That's Stallman's definition of freedom and even so it doesn't mean freedom for developers but for source code.
Here we start again. Yes freedom defined as by Stallman that is "(0) to run the program, (1) to study and change the program in source code form, (2) to redistribute exact copies, and (3) to distribute modified versions". For me it's freedom, but you don't have to agree, for some people being able to use Discord for gratis is freedom too, we don't have to agree. For you freedom is also being able to make the code proprietary and hurt people by that and it's your right to think in this way, but I don't have to agree either.
But anyway that's not what this thread and my post was about, so we better stop here, because this discussion will lead us nowhere.

Juan Reed
Juan Reed

WE DON'T HAVE TO AGREE
why even fucking post if you will not only not argue your point, but not state it.

Adam Evans
Adam Evans

why even fucking post if you will not only not argue your point, but not state it.
I posted, because you had confused gtk+ and gpl, that's all. Everything but that was just an icing on the cake. I don't want to start the shitstorm once again. Also saying 'freetard' implies freedom is retarded at all, if you value freedom in whatever form, you should not use this propaganda, because it's mostly repeated by people using proprietary software and being exploited by greedy motherfuckers.

Blake Harris
Blake Harris

muh freedom muh freedom muh freedom
You absolute simpleton still don't get that it's just one man's definition of that word. Thus, freetard.

Landon Wood
Landon Wood

AFAIK Stallman was the first one, who defined the term "free software", so it is fair to use it in this way.

Henry Morgan
Henry Morgan

You're on a freetard board faggot, go back to /g/

Attached: why-are-you-gay.webm (1.84 MB, 1280x720)

Luke Johnson
Luke Johnson

I only use software that respects my freedom. Public domain or BSD. TYVM

Adam Wood
Adam Wood

Irrelevant and stupid. Stallman simply took a term that is universally considered good (free, freedom) and then did the classic jew trick of applying it to his own bullshit license. Then nonthinking freetard brainlet automatons to this day go around asking "lol why u hate freedom". It's exact same sleigh of hand as lefties always promoting "justice" (universally good thing) but in the end it just means their policies but their braindead npc followers confront others asking "lol why u hate justice" exact same as freetards. Thus, freetards. Nonthinking, retarded, automatons. Freetards.

Attached: 1453396754094.png (1.02 MB, 880x920)

Blake Price
Blake Price

Stallman simply took a term that is universally considered good (free, freedom) and then did the classic jew trick of applying it to his own bullshit license.
Here you're wrong, not only the GPL is considered as a free license.
gnu.org/licenses/license-list.html

I only use software that respects my freedom. Public domain or BSD.
Like freedom of corporations to use your code to mistreat someones freedom? People choosing the GPL are people, who don't want to have freedom of hurting others by not giving them source code. It's like forbidding slavery - it surely takes away freedom of those, who want to have slaves, but is good because more people have freedom, it's a right thing to do.

Christopher James
Christopher James

Like freedom of corporations to use your code to mistreat someones freedom?
No you misread me. I only WRITE proprietary software. I only USE public domain / BSD.

Asher Anderson
Asher Anderson

This is pretty much accurate.

It's like forbidding slavery
lmao yeah it's exactly like that.

Nathaniel Thompson
Nathaniel Thompson

What part of that message you don't understand? That organisation GNU started by Stallman labels other licenses as "free" to certain degree (where GPL (his invention) obviously is very definition of "free" with nothing ever possibly being more "free" than it as an axiom based on fucknothing) is not surprising at all, it's to be expected. Again: it's the classic jew trick of using a word universally considered good and using that as descriptor for something. Read that message again. The only honest description with no disagreements or implications for GPL is just GPL. But Stallman did the word trick.

Ayden Martinez
Ayden Martinez

No you misread me. I only WRITE proprietary software. I only USE public domain / BSD.
I only WRITE proprietary software.
Wow I'm really sorry about those cucks that wrote the software you're using now. It's cool to talk to others what freedom is and what isn't especially when you're just parasite on the free software world and you contribute nothing.

Stallman labels other licenses as "free" to certain degree (where GPL (his invention) obviously is very definition of "free" with nothing ever possibly being more "free" than it as an axiom based on fucknothing)
Really? Let's see what's on the website.
<GNU General Public License (GPL) version 3
<This is the latest version of the GNU GPL: a free software license, and a copyleft license. We recommend it for most software packages.
Nothing about being the most free license.
<GNU Lesser General Public License (LGPL) version 3
<This is the latest version of the LGPL: a free software license, but not a strong copyleft license, because it permits linking with nonfree modules. It is compatible with GPLv3. We recommend it for special circumstances only.
Still.
<Apache License, Version 2.0
<This is a free software license, compatible with version 3 of the GNU GPL. Please note that this license is not compatible with GPL version 2, because it has some requirements that are not in that GPL version. These include certain patent termination and indemnification provisions. The patent termination provision is a good thing, which is why we recommend the Apache 2.0 license for substantial programs over other lax permissive licenses.
Nothing about being less free than GPL.
<Modified BSD license
<This is the original BSD license, modified by removal of the advertising clause. It is a lax, permissive non-copyleft free software license, compatible with the GNU GPL.
<This license is sometimes referred to as the 3-clause BSD license. The modified BSD license is not bad, as lax permissive licenses go, though the Apache 2.0 license is preferable. However, it is risky to recommend use of “the BSD license”, even for special cases such as small programs, because confusion could easily occur and lead to use of the flawed original BSD license. To avoid this risk, you can suggest the X11 license instead. The X11 license and the modified BSD license are more or less equivalent. However, the Apache 2.0 license is better for substantial programs, since it prevents patent treachery.
Here they don't say GPL is the most free one either, they only mention a technical problem of the original BSD license described below
<Original BSD license
<This is a lax, permissive non-copyleft free software license with a serious flaw: the “obnoxious BSD advertising clause”. The flaw is not fatal; that is, it does not render the software nonfree. But it does cause practical problems, including incompatibility with the GNU GPL.
They explain the practical reasons not to use it here:
gnu.org/licenses/bsd.en.html
And still nothing about the original BSD license being less free or extremely bad, they even say:
<Copyleft licenses such as the GNU GPL insist that modified versions of the program must be free software as well. Non-copyleft licenses do not insist on this. We recommend copyleft, because it protects freedom for all users, but non-copylefted software can still be free software, and useful to the free software community.
If you can find a place where they say the GPL is the most free license, and other licenses (copyleft or non-copyleft) are less free, please show me, because for now things you say seem to be baseless accusations. The GPL was written in this way because of practical reasons, here is the article about it gnu.org/philosophy/why-copyleft.html.en

Parker Perez
Parker Perez

Based. Giving new meanings to words is one of the most common jew tricks in history.

Ryder Ramirez
Ryder Ramirez

People choosing the GPL are people, who don't want to have freedom of hurting others by not giving them source code.
That argument is bullshit tbh, because if those people are annoyed about not having access to source code, then they can choose a free option that gives them source code. Stop moralfagging and making what is really a self-centered issue about "others". It's not. You choose the GPL because you don't want corporations using your code.

James Moore
James Moore

Again: it's the classic jew trick of using a word universally considered good and using that as descriptor for something.
This.

Bentley Rodriguez
Bentley Rodriguez

That's false. Stallman's definition of free software based on the axiom that users have the right to control their own computing and also the right to share with their community.

Jonathan Perez
Jonathan Perez

I very happy for corporations to use my code and make big profits selling my code. What I disapprove is for anybody (whether corporations or individuals) distribute my code as proprietary software. If they want to distribute and sell my code, then they must provide the recipient the right to practice the four freedoms of free software.

Brody Sanders
Brody Sanders

I very happy for corporations to use my code and make big profits selling my code without any compensation or even recognition whatsoever for me oh and I don't have any rights or claim to what I wrote either.
Good goy. You are truly free hehe.

Lincoln Price
Lincoln Price

Who are you quoting?

James Reed
James Reed

Oh you are the guy that replies "who are you quoting" in every thread

Attached: D5wfDzyWAAc8BNc.jpg (18.5 KB, 720x467)

Camden Brown
Camden Brown

What's a usb line?

Jason Baker
Jason Baker

what

Attached: 1561777954567.jpg (76.1 KB, 460x578)

Liam Campbell
Liam Campbell

Who are you quoting, cuckchan?

Adrian Ross
Adrian Ross

I very happy for corporations to use my code and make big profits selling my code. What I disapprove is for anybody (whether corporations or individuals) distribute my code as proprietary software. If they want to distribute and sell my code, then they must provide the recipient the right to practice the four freedoms of free software.
As soon as they contribute and give something back, it's probably okay, because they spread freedom.