[ mona / prog / sol ]

prog


 

How can I run my own instance of this

1 2019-01-21 01:37

Say I want to make a text board using this script How would I go about making more boards in customizing the index to my liking

2259

260 2020-05-31 14:48

>>259

I've just tried Github and Gitlab without Javascript for a quick laugh. [...] Can you see the tickets now?

Github is actually one of the only one of these larger “vcs platforms” which renders decently for me. The ticket system now works as described in eww. Of note is that the ticket are also viewable by cloning the repo and using `fossil ticket' command: https://fossil-scm.org/home/help?cmd=ticket if I understand correctly (I haven't yet installed fossil).

261 2020-05-31 15:01

To be clear >>258 is not the same anon as >>260 so they might still have issues, but it would be on their end if they exist.

262 2020-05-31 20:31

>>259

Can you see the tickets now?
https://www.fossil-scm.org/fossil/tktview?name=d13e296bd5

You mean after access has been enabled? Sure. Also:

because the internet is a hostile place and spiders would overrun our bandwidth quota if we did.

Thanks for the laughs.

263 2020-06-01 01:20

Now that tickets are accessible and I can actually read the issue, here's what happens. In https://bbs.jp.net/sexp/prog/39 the text of >>194 starts with "お疲れさん.", whatever that is, sent as the bytes:

0002ca50  6f 6e 74 65 6e 74 20 28  70 20 28 61 20 28 40 20  |ontent (p (a (@ |
0002ca60  28 68 72 65 66 20 22 2f  70 72 6f 67 2f 33 39 2f  |(href "/prog/39/|
0002ca70  31 39 32 22 29 29 20 22  3e 3e 31 39 32 22 29 20  |192")) ">>192") |
0002ca80  28 62 72 29 20 22 e3 5c  32 30 31 5c 32 31 32 e7  |(br) ".\201\212.|
0002ca90  5c 32 32 36 b2 e3 5c 32  30 32 5c 32 31 34 e3 5c  |\226..\202\214.\|
0002caa0  32 30 31 5c 32 32 35 e3  5c 32 30 32 5c 32 32 33  |201\225.\202\223|
0002cab0  2e 22 20 28 62 72 29 20  22 4e 6f 77 2c 20 49 27  |." (br) "Now, I'|
0002cac0  76 65 20 62 65 65 6e 20  6d 65 61 6e 69 6e 67 20  |ve been meaning |

The relevant bytes are:

>>> s = "e3 5c  32 30 31 5c 32 31 32 e7 5c 32 32 36 b2 e3 5c 32  30 32 5c 32 31 34 e3 5c 32 30 31 5c 32 32 35 e3  5c 32 30 32 5c 32 32 33 2e"
>>> b = bytes (int (t, base = 16) for t in s.split ())
>>> b
b'\xe3\\201\\212\xe7\\226\xb2\xe3\\202\\214\xe3\\201\\225\xe3\\202\\223.'

The original string in utf8 is:

>>> "お疲れさん.".encode ("utf8")
b'\xe3\x81\x8a\xe7\x96\xb2\xe3\x82\x8c\xe3\x81\x95\xe3\x82\x93.'

so it is obvious that we have high bytes followed by backslashed octal escapes. In the bytes of >>64 a textual backslash can be seen to be doubled.

0000deb0  6e 20 20 28 6c 65 74 2a  20 28 28 72 31 20 28 73  |n  (let* ((r1 (s|
0000dec0  74 72 69 6e 67 2d 73 70  6c 69 74 20 72 61 6e 67  |tring-split rang|
0000ded0  65 20 23 5c 5c 2c 29 29  5c 6e 20 20 20 20 20 20  |e #\\,))\n      |

So we just need to process the octals before the utf8 decoding:

>>> f = lambda b: bytes (int (b [4*k+1 : 4*k+4].decode ("ascii"), base=8) for k in range (len (b) // 4))
>>> g = lambda b: re.sub (rb"([\x80-\xff])((\\[0-7]{3})+)", lambda mo: mo.group (1) + f (mo.group (2)), b).decode ("utf-8")
>>> g (b)
'お疲れさん.'

Just do the equivalent of this in elisp and you can have your weeb characters. Someone might send this to the sbbs.el person.

264 2020-06-01 02:47

Imagine there is a line with

>>> import re

anywhere before the g(b) call >>263, for the re.sub in g. It didn't make it through the copypasting but it was obviously there in the original because the g(b) call returned a result rather than raising a NameError.

265


VIP:

do not edit these



 

The decentralized Internet is a mess

1 2020-03-15 17:15

There's no standard, no central resource to learn about it and too many concurrent projects.

The blockchain, Secure Scuttlebutt, IPFS, Radicle, Mastodon, Project Xanadu, to name a few. Where does one even start?

234

35 2020-05-21 10:04

enabling offline/mainly offline usage

That's self-inconsistent. You can't use what's offline. If it's usile, it's online. Enabling use of it entails making it online.

The closest existing thing is probably E-Mail

This is instructive. eMail is a great decentralized peer-to-peer application, with some major flaws. Some are trying to compete with this great, flawed, popular system.

The Internet is completely decentralized.

No, it's not. And there's no such thing. Nothing is completely decentralized, except grey goo vel cetera. An internet, fundamentally, is a noncentralizate. Nonetheless, a centralizate can comprise noncentralizates.

I don't know the proper name. Decentralized web applications? Peer-to-Peer applications?

How about calling it ``you have your stuff, I have my stuff; let's have our stuff interact, without any 3^{rd}-party'' as an extension of the ``what happens among some mutually consenting persons that doesn't affect anyone else, is the concern of only those mutually consenting persons, unless those mutually consenting persons make it someone else's concern'' principle---using general personhood, naturally.

It seems that you're lacking some fundamental understanding. The 1^{st} question you should ask is whether you understand each fundamental informatical, relevant mathematical. (You might read Knuth's The Art Of Computer Programming.) If you understand these, then it should be easy to learn about a particular informatical, starting with special informaticals, germane mathematicals. (The 0^{th} question you should ask is whether you understand solipsism.)

I can't write about all these protocols if I haven't studied them thoroughly. And for that I need to read this document first, or any similar centralized synthetic resource.

No. It's sufficient to read such a document first. Probably, it's not necessary, but better, to understand about what you write.
What would Knuth do?

study each [related] software thoroughly ... comparing them
synthetizing a high-level overview

Each serious project should be such that any general intelligence can easily work with it.

Write the document first, and then think about where to publish it.

And when you write the document, consider each way you can publish it, to write it so that it's easy to translate to a form that's easy to publish in many (try: each) those ways.

36 2020-05-21 12:08

>>35

No, it's not. And there's no such thing. Nothing is completely decentralized, except grey goo vel cetera. An internet, fundamentally, is a noncentralizate. Nonetheless, a centralizate can comprise noncentralizates.

I mean I guess the Internet technically is not completely decentralized because of ICANN, but I think that's an abstraction layer below what we're talking about here. Decentralized is defined as not centralized. So at the level of abstraction we're talking about the Internet is decentralized but not distributed, there are lots of servers, which aren't centrally planned, but there is still a client server distinction.

37 2020-05-21 18:40 *

>>35

No, it's not. And there's no such thing. Nothing is completely decentralized, except grey goo vel cetera.

What? Of course there are decentralised networks, human relations or relations within a virtual social network are decentralised, are prominent examples.

38 2020-05-31 09:38

WebTorrent Workshop

https://webtorrent.github.io/workshop/

39 2020-05-31 20:46

``Decentralized'' is defined as not centralized.

No, it's not. The prefix ``de-'' (likewise, ``dis-'') signifies retraction (posterior inverse); i.e. deX X = e (e = identity) e.g. decentralize after centralize = null action.
To be perfectly clear: decentralize = de- ( ( (center) -al) -ize);
decentralize = de- centralize,
centralize = central -ize,
central = center -al.

>>37

>Nothing is completely decentralized, except grey goo vel cetera.
What? Of course there are decentralised networks, human relations or relations within a virtual social network are decentralised, are prominent examples.

Nothing is completely decentralized. Read thoroughly and comprehend what was read before attacking us with your banality.

40


VIP:

do not edit these



 

scheme vs common lisp

1 2020-05-31 00:52

Which one should I learn?

23

4 2020-05-31 07:44

>>3
Learning Scheme first can make it harder to get into CL, or you get more annoyed by the historical baggage.
CL is better enjoyed when you accept that it isn't functional, which isn't bad in itself.

5 2020-05-31 08:59

>>4
Honestly, I actually find the historical baggage to be rather charming but I do realise I'm in the minority. I first got into Scheme for being a dynamically typed functional language (the only alternative was Erlang) and soon fell in love with the macro system and expressiveness of Lisp. Still, I find writing bluntly imperative code to be very annoying, which mostly keeps me away from CL for most tasks.

6 2020-05-31 18:16

>>3 how is common lisp not functional? I don't know anything about functional programming except that you use functions for everything

7 2020-05-31 19:09

>>6
There are different definitions of "functional languages", but I consider 1. functions are data 2. functions are composed 3. data is immutable to be the general style. Now languages can either support or enforce this. If supporting is enough, then C is functional (1. function pointers; 2. eg. qsort; 3. const).
But because this seems absurd, I prefer to say that these kinds of languages "support a functional style". Functional languages either have to be designed so that a functional style is intended (Scheme) or required (Haskell).
Common Lisp can be programmed in a functional style, but you're going to suffer inefficiencies, because you're expected to think about memory and garbage collection (when to use nreverse or reverse). Also mutation is quite central, something you easily recognize when considering all the macros that work on generalized variables (setf, push, rotatef, ...).
So all in all, you can write bits and pieces in a functional style, and knowing when doing so aids performance and readability is what one learns with time, but the trying to do everything as if it were Haskell, is not the best approach.
(IMO)

8 2020-05-31 19:47

>>6 At one time, people talked about functional programs as being made up of expressions. Evaluate the expressions (by function application) and you have your program. I think in this sense CL

But then people became more concerned with pure functions, which don't have side effects and always have the same output for the same input. Purely functional scheme, for instance, would mean not using set! or any other ! functions. Since even updating a database, saving a file, or opening a window are side effects, you can't get much done purely.

If you look at the implementation of the SRFIs or grep over your scheme, you can see it's rife with set!, so as far as scheme being functional in this sense, it's mainly just that users are encouraged to localize their use of these functions and make as many functions as they can pure.

But scheme is not purely functional.

But in CL you can, for instance, update a class, and all the running instances of that class will update to be instances of the new class. That doesn't sound very functional (in the pure sense) but it does sound good for development.

9


VIP:

do not edit these



 

Small programming projects ideas

1 2020-05-24 00:20

Share programming tasks that you considered doing at some point but realized you lack the time or motivation and that could be an interesting task for someone else.

Here's one: rewrite Notational Velocity for Linux. The Python clone is awful, so don't use Python or another slow scripting language. NV was the best and simplest note taking software ever made (for people too lazy to get into Org-mode)

http://notational.net/

It only works on OSX 10.4-10.7 so you'll need an old mac or a VM to run it.

212

13 2020-05-29 07:33

ox-schemebbs

14 2020-05-29 07:43

>>13
What would that do?

15 2020-05-29 08:37

SOCKS library for Racket

16 2020-05-31 19:27

>>5
https://getgle.org/news/ sounds like what you're looking for

17 2020-05-31 20:18 *

>>16

Stormfront as source

18


VIP:

do not edit these



 

Lisp beginner thread

1 2020-03-05 19:22

Shall we have a beginner thread?

246

47 2020-05-30 18:42

>>45
R7RS is spartan but there are a few excellent design decisions that I wish were in R6RS as well. For instance, it has a well-defined cond-expand that is much better than SRFI-0. Not all R6RS implementations implement SRFI-0 anyway (Chez, for instance) so you need to resort to the de facto file suffix trick (eg foo.guile.scm, foo.sagittarius.scm, foo.larceny.scm for a foo library). Stuff like this gives me faith about R7RS Large being built on a strong foundation.

48 2020-05-30 19:42

>>47
I was just trying to say that there are actually very few incompatibilities between R7RS and R6RS. Most of the difference and advantage is in strictly defined semantics of R6RS which are compatible with the loosely defined semantics of R7RS. There are some differences which are significant like the exception system, and syntax-case, but for the most an implementation of R7RS can give you almost all of the benefits of R6RS. There is hope that R7RS Large will even allow for the expression of these remaining features of R6RS. This is the approach of Larceny and Sagittarius in any case (Larceny implement R7RS Red Edition as well).

49 2020-05-30 20:12

>>48
I apologize for my poor use of English here, hopefully you understand my meaning.

50 2020-05-30 20:31 *

>>49
Don't worry, it's an International English-speaking board (aka Tanzanian English or Tarzan English). The whole world speaks it, that's the point. It can only trigger a tiny minority of 0xf0rder English speakers

51 2020-05-31 13:55

I won't finish my current text until the end of June at my current pace (excluding Sundays), but I'm considering the next text to study anyway. Is “Concrete Mathematics” (0-201-55802-5) considered a good introduction to analysis of algorithms, especially for someone with a strong background in mathematics? Most of the reviews I have seen have been people discussing the typography, describing how it's a poor choice for people with a poor mathematical background, or saying it's a great text to prepare for graduate school without any real reference to the content. Does this text rely on more than a rudimentary initial understanding of analysis of algorithms by the reader, and if not does it teach analysis of algorithms or its foundations in a manner that is useful and generally applicable?

52


VIP:

do not edit these



 

Image manipulation and OCR

1 2020-05-30 16:58

I've been thinking about getting into computer imagery and sharpening my programming skills by solving some images-related problems. I don't have experience with programming images at all and I'd like to learn how they're designed, their terminology, common concepts and operations. I'm setting my goal to implement something similar to this https://htmlpreview.github.io/?https://github.com/sakarika/kanjitomo-ocr/master/how%20it%20works/index.html

What do you think is a great way to start working with such concepts? is there like a roadmap to learn basic operations on images and then gradually learn and improve? please share resources if you have any.

2 2020-05-30 22:48 *

>>1
If you're an absolute beginner, start to play with PBM. It's fun and dead simple.

https://en.wikipedia.org/wiki/Netpbm

Save the file below as kaomoji.pbm, then open it in Gimp for instance.

P1
# Created by GIMP version 2.10.18 PNM plug-in
47 13
00000000000000000000000000000000000000000000000
00010001000000000000000000000000000000100001000
00100010000000000000000000000000000000010000100
01100000000000000000000000000000000000000000110
01000000000011100000110001100000111000000000010
01000000000011100000100000100000111000000000010
01000000000011100000100100100000111000000000010
01000000000000000000100100100000000000000000010
01000000000000000000100100100000000000000000010
01100000000000000000011011000000000000000000110
00100000000000000000000000000000000000000000100
00010000000000000000000000000000000000000001000
00000000000000000000000000000000000000000000000
3 2020-05-31 00:39 *

Start with the MNIST database of handwritten digits, it's a common entry point and you'll find countless tutorials.
http://yann.lecun.com/exdb/mnist/

Here's for instance an ANN with forward propagation that I wrote for this challenge. It was a lesbillion years ago, so forgive the poor code quality. You need to install cblas hdf5 and gsl.

#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <time.h>
#include <math.h>
#include <hdf5.h>
#include <hdf5_hl.h>
#include <gsl/gsl_cblas.h>

void random_numbers(int n, int m, int *num)
{
    int i, in, im, *is_used;
    srand((unsigned int) time(NULL));
    is_used = malloc(n * sizeof(int));
    for (i = 0; i < n; ++i) is_used[i] = 0;
    im = 0;
    for (in = n - m; in < n && im < m; ++in) {
        int r = rand() % (in + 1);
        if (is_used[r]) r = in;
        assert(!is_used[r]);
        num[im++] = r;
        is_used[r] = 1;
    }
    assert((im = m));
    free(is_used);
}

herr_t load_matrix(char *filename, char *matrix_name, float *data)
{
    hid_t file_id;
    hsize_t dims[2];
    herr_t status;
    file_id = H5Fopen(filename, H5F_ACC_RDONLY, H5P_DEFAULT);
    status = H5LTread_dataset_float(file_id, matrix_name, data);
    status = H5LTget_dataset_info(file_id, matrix_name, dims, NULL, NULL);
    return(status);
}

int main()
{
    size_t X_size, y_size;
    float *X, *y, *Theta1, *Theta2, *L2, *L3, *test;
    int i, n, max, *rand_num;
    int errors = 0;
    X_size = 5000 * 400;
    X = malloc(X_size * sizeof(float));
    load_matrix("data/dataset.h5", "X", X);
    y_size = 5000;
    y = malloc(y_size * sizeof(float));
    load_matrix("data/dataset.h5", "y", y);

    /* choose 100 randoms images in X */
    rand_num = malloc(100 * sizeof(int));
    random_numbers(5000, 100, rand_num);

    /* test the 100 random digits */
    test = malloc(401 * sizeof(float));
    Theta1 = malloc(401 * 25 * sizeof(float));
    Theta2 = malloc(26 * 10 * sizeof(float));
    L2 = malloc(26 * sizeof(float));
    L3 = malloc(10 * sizeof(float));
    for (n = 0; n < 5000; ++n) {
        /* test data no 1203 */
        test[0] = 1;
        for (i = 0; i < 400; ++i) {
            test[i+1] = X[n + i * 5000];
        }
        /* load Theta1, 401x25 matrix of weights for the hidden layer */
        load_matrix("data/weights.h5", "Theta1", Theta1);

        /* layer 2 is 26x1 */

        /* multiply */
        cblas_sgemm(CblasRowMajor, CblasTrans, CblasNoTrans, 25, 1, 401, 1.0, Theta1, 25, test, 1, 0.0, L2 + 1, 1);
        /* sigmoid */
        for(i = 1; i < 26; ++i) {
            L2[i] = 1 / (1 + exp(-L2[i]));
        }
        /*add bias value */
        L2[0] = 1;

        /* Layer 3 */

        /* load Theta2, 26x10 matrix of weights for the output layer */
        load_matrix("data/weights.h5", "Theta2", Theta2);
        /* output layer is 10x1 */
        cblas_sgemm(CblasRowMajor, CblasTrans, CblasNoTrans, 10, 1, 26, 1.0, Theta2, 10, L2, 1, 0.0, L3, 1);
        /*get the max value*/
        max = 0;
        for (i = 0; i < 10; ++i) {
            if (L3[i] > L3[max]) max = i;
        }
        if ((max + 1) % 10 != (int) y[n] % 10) {
            printf("%4d - predicted: %d | digit is: %d\n", n, (max + 1) % 10, (int) y[n] % 10);
            errors++;
        }
    }
    printf("accuracy: %f\n", 100 * (5000 - (float) errors) / 5000); 
    free(X);
    free(y);
    free(test);
    free(L2);
    free(L3);
    free(Theta1);
    free(Theta2);
    free(rand_num);    
    return 0;
}

I've put the MNIST dataset in HDF5, you can download it here: https://send.firefox.com/download/7f815eb602434217/#CjjlBzTawTx8CFGP_uGpxg (link will expire in 7 days)

gcc -Wall -pedantic -lhdf5 -l hdf5_hl -lgslcblas -ldl -lm fw_propagation.c
./a.out
... (list of errors)
accuracy: 97.519997

Not awful but nothing to boast about. I found this code on an old hard disk, it doesn't seeem to choose digits randomly. It's either bit rot or I got bored with it without even finishing. I don't remember, I was surprised it's still compiling.

4 2020-05-31 00:57 *
                                      ████    ████                    
                                      ████  ██████                    
                                    ████  ██████                      
                                    ████  ██████                      
                                  ████████████    ██████              
                                  ██████████  ██████████              
                              ▓▓▓▓██████████████████                  
            ▓▓▓▓        ▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▓▓██████                      
          ▓▓▒▒▒▒██  ▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒████                    
        ▓▓▒▒▒▒▒▒▒▒▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒██                  
        ██▒▒▒▒▒▒██▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒██                
      ██▒▒▒▒▒▒██▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓▒▒▒▒▒▒▒▒▒▒██              
    ██▒▒▒▒▒▒▒▒▓▓░░░░░░▓▓▒▒▒▒▒▒▒▒▒▒▓▓░░░░░░▒▒▓▓▒▒▒▒▒▒▒▒████            
  ██▒▒▒▒▒▒▒▒██░░░░██░░▒▒▓▓▒▒▒▒▒▒▓▓░░░░██░░░░▒▒▓▓▒▒▒▒██▒▒▒▒██          
  ██▒▒▒▒▒▒▒▒██░░░░░░░░▒▒▓▓▒▒▒▒▒▒██░░░░░░░░░░▒▒██▒▒████▒▒▒▒▒▒██        
██▒▒▒▒▒▒▒▒▒▒██▓▓░░░░▒▒▒▒██████▒▒▒▒▓▓░░░░░░▒▒▓▓▒▒██▒▒▒▒▒▒▒▒▒▒██        
██▒▒▒▒▒▒▒▒▒▒██▒▒▓▓▓▓▓▓██░░░░▒▒████▒▒▓▓████▓▓▒▒▒▒██▒▒▒▒▒▒▒▒▒▒▒▒██      
██▒▒▒▒▒▒▒▒▒▒▓▓██▒▒████░░░░░░▒▒▒▒▓▓████▓▓▒▒▒▒▒▒▒▒▒▒██▒▒▒▒▒▒▒▒▒▒██      
██▓▓▒▒▒▒▒▒▓▓▓▓████░░██░░░░░░██▒▒▓▓▓▓▓▓▓▓██▒▒▒▒▓▓▓▓██▒▒▒▒▒▒▒▒▒▒▓▓██    
  ██▓▓▓▓▓▓▓▓▓▓▓▓██░░▓▓░░░░▓▓▒▒▒▒▒▒▓▓▓▓▓▓██▓▓▓▓▓▓▓▓██▒▒▒▒▒▒▒▒▒▒▓▓██    
  ██▓▓▓▓▓▓▓▓▓▓██░░░░░░░░░░░░░░▒▒▒▒▓▓▓▓██▓▓▓▓▓▓████▓▓▒▒▒▒▒▒▒▒▓▓▓▓██    
    ██▓▓▓▓▓▓████░░░░░░░░░░░░░░▒▒▓▓▓▓▓▓████████▓▓██▓▓▓▓▒▒▒▒▓▓▓▓▓▓██    
      ████▓▓██░░░░░░░░░░░░░░▒▒▒▒▓▓▓▓██▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓██      
          ██░░░░░░░░░░░░░░░░▒▒▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██      
        ██░░░░░░░░░░░░░░░░▒▒▒▒▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██        
        ██▒▒░░░░░░░░░░▒▒▒▒▒▒▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██        
          ██▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██      ████
          ██████▓▓▓▓▓▓▓▓▓▓██████▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██  ████▒▒▒▒██
          ██▒▒▒▒██████████▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓████▒▒▒▒▒▒▒▒██
        ██▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▒▒██
        ██▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓▓▓██
        ██▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓██  
        ██▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓▓▓██  
          ██▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓██    
          ██▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██▓▓██      
            ██▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓████        
              ██▒▒▒▒▒▒▒▒▒▒▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓██            
                ████▓▓▒▒▒▒▓▓▒▒▓▓▒▒▓▓▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓████              
              ████▓▓██████▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓████████                
          ████▒▒▒▒▓▓▓▓▓▓▓▓████████████████████▓▓▓▓▓▓▓▓██              
        ██▒▒▒▒▓▓▒▒▒▒▒▒▓▓▓▓▓▓▓▓▓▓██      ██▓▓▓▓▓▓▒▒▓▓▓▓▓▓████          
          ████▒▒▒▒██▒▒▒▒▓▓██████      ██▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓▓▓██        
            ████████▓▓▓▓████          ██▒▒▒▒▒▒██▒▒▒▒▓▓▓▓▓▓▓▓██        
                  ██████                ████████▓▓▒▒▒▒██████          
                                                ████████              
5 2020-05-31 00:59 *

Yes, netpbm is a lot of fun. Those programs would have been lost without tinychan's archive: https://archive.tinychan.net/read/prog/1350134190

6 2020-05-31 11:18

>>3
Firefox link doesn't work? Can you please re-upload it?

7


VIP:

do not edit these



 

Bringing GNU Emacs to Native Code

1 2020-05-07 10:59

https://toobnix.org/videos/watch/1f997b3c-00dc-4f7d-b2ce-74538c194fa7

2 2020-05-08 21:01

>>1
Interesting. He says it's stable for production in the video but isn't so assertive in his webpage: http://akrl.sdf.org/gccemacs.html

I've never looked into elisp's bytecode, there's a project to document it here: https://cdimage.debian.org/debian-cd/current/amd64/iso-cd/debian-10.3.0-amd64-netinst.iso

3 2020-05-08 21:02

wrong link, pdf about LAP is here: http://rocky.github.io/elisp-bytecode.pdf

4 2020-05-31 09:44

This talk advocates the rarely discussed view that Emacs Lisp is good, actually, and that Emacs should be written in Emacs Lisp. Threading, compilation, and addressing Emacs' other low-level deficiencies will be covered, with an eye toward a practical way to roll out the changes.

https://fosdem.org/2020/schedule/event/emacsthoughts/

5


VIP:

do not edit these



 

What is the most underrated Scheme implementation?

1 2020-05-26 05:13

I'd say Gauche or Kawa.

Gauche is excellent for system programming but obscured by Guile. Kawa running on the JVM and being ENTERPRISE QUALITY is looked down upon.

27

8 2020-05-26 17:44 *

>>4
Yes.
https://www.gnu.org/software/kawa/Building-for-Android.html

It's also been used in MIT App Inventor:
https://en.wikipedia.org/wiki/App_Inventor_for_Android

9 2020-05-26 20:23 *

>>3
I kind of lump together those Scheme implementations that I never tried even though they all seem very good: Sagittarius, Cyclone and Larceny. I know they're unrelated but they're like new kids on the block to me.

10 2020-05-29 21:59

s7 is a pretty fast r5/r7rs embedded Scheme with first-class environments and setf.
https://ccrma.stanford.edu/software/snd/snd/s7.html

11 2020-05-29 22:35

Since it's not mentioned and it passes all the chicken scheme benchmarks and looks pretty fast, there's cyclone. But yes s7 looks interesting. And microscheme.

12 2020-05-30 03:10

Speaking of Chicken, the original author has another implementation called Bones which is an r5rs that compiles directly to x86_64 machine code.
http://www.call-with-current-continuation.org/bones/

Another quite interesting implementation is Owl Lisp which is a "purely-functional" (in the sense of immutability; side-effects are still okay) subset of r7rs that ought to compile in pretty much any vaguely UNIX-y environment. It's full of clever tricks and has an eloquently-minimal vm and compiler-to-C. As an example of the clever tricks, it's got a system similar to erlang processes, IE closures with messageboxes, that you can use to simulate mutable state. There are some other immutable datastructure tricks to get efficient-enough, but conceptually much simpler under the hood, approximations of hashtables. Only thing is the documentation is essentially non-existent; you've got to look at the library source files. Still, it's fiendishly clever for how small and simple it is. A true embodiment of the minimal 'spirit' of Scheme.
https://gitlab.com/owl-lisp/owl

13


VIP:

do not edit these



 

I2P Meta

1 2020-05-30 00:13

Can you fix /mona/? It's not working over I2P.

23

4 2020-05-30 23:58 *

>>3
Redirect worked but ended up on the clearnet, encase you wanted to know.

5 2020-05-31 02:51 *

>>4
Configure your outproxies. If I try to reach /mona/ I'll get

Proxy error: Outproxy failure

Host bbs.jp.net not inside I2P network, but outproxy is not enabled

Unless you're using Tor as your outproxy, you're too easily deanonymized.

6 2020-05-31 08:20 *

>>5
I never had a good time with outproxies after all of these years..... Tell me when the reverse proxy is setup correctly for /mona/ or whatever you decide as a solution.

This isn't nginx but I might as well post it, the forgery problems with reverse proxies should become obvious.

"Host: site.i2p"
  "URL: /mona/*"
    "Socket: /var/run/httpd/sock"
"Host: unrelated.admin.local"
  "URL: /admin/*"
    "Socket: /var/run/webadmin/sock"
7 2020-05-31 16:49 *

>>6

Tell me when the reverse proxy is setup correctly for /mona/ or whatever you decide as a solution.

You should now be able to access /mona/ through I2P. I wanted to keep the boards on separate domains but it doesn't really matter. Choose your favorite domain and go to any of the 3 boards.
https://bbs.jp.net/prog
https://textboard.org/mona
http://textboard.i2p/sol

8 2020-05-31 23:13 *

>>7
It works now.

9


VIP:

do not edit these



 

Emacs mode for SchemeBBS markup

1 2020-02-16 22:22
(require 'generic-x)
(define-generic-mode schemebbs-mode
  nil nil
  '(("\\(\\*\\*.+\\*\\*\\)" 1 font-lock-keyword-face)           ; bold
    ("\\(__.+__\\)" 1 font-lock-comment-face)                   ; italic
    ("\\(==.+==\\)" 1 font-lock-constant-face)                  ; monospaced
    ("\\(~~.+~~\\)" 1 font-lock-type-face)                      ; spoiler
    ("^\\(>.+\\)" 1 font-lock-doc-face)                         ; quotes
    ("^\\(```\n\\(.+\n\\)+```\\)$" 1 font-lock-reference-face)) ; code
  nil nil
  "Basic highlighting for composing SchemeBBS posts.")
238

39 2020-05-28 14:34 *

https://www.fossil-scm.org/fossil/doc/trunk/www/xkcd-git.gif

40 2020-05-28 18:14

>>38
Yes, that will work. I'm curious to see how it will work.

41 2020-05-28 21:27 *

>>40
I sent you a mail with your logins. You've got admin rights over the repo in case you want to add users or anything.

42 2020-05-29 11:56

To anyone interested in contributing, sbbs has totally transitioned over to fossil. The ticket list has all the issues listed https://fossil.textboard.org/sbbs/rptview?rn=1, and the wiki has a home, a usage and contribution page. As far as I see, anyone can contribute to the ticket list, so if there any bugs or feature requests, feel free to do so.

The only thing remaining is updating the link on the preference page.

43 2020-05-29 20:10 *

>>42

The only thing remaining is updating the link on the preference page.

[x]

44


VIP:

do not edit these



New Thread





do not edit these