bad_login

I will break don't my past salary in france to give people a better idea.

2200€ in my pocket each month with health care and taxes paid.

My yearly gross salary 39_000€. My yearly super-gross salary (what the company actually pay) 54_000€.

Actually the company paid less due to CIR (https://entreprendre.service-public.gouv.fr/vosdroits/F23533) I don't the number but at absolute minimum the company could have paid 31_320€.

I live in the south east of france not in a big city and I have 13 years of xp.

And to compare to the cost of life :

  - 200g of bread is 1€.
  - tomato 4€/kg
  - beef 27-40€/kg
  - 100m2 individual house 350_000€
  - 60m2 flat 150_000€

What about "wasteland" ?

Maybe tweaking the rules of the parser and check if it reduce the size of : #define STATE_COUNT 20290 #define LARGE_STATE_COUNT 10594

in parser.c

Here is the racket view of xml

https://docs.racket-lang.org/sxml/SXML.html

more examples: https://docs.racket-lang.org/sxml/ssax.html

and then you can manipulate your sxml with https://docs.racket-lang.org/reference/match.html

Ah ah like when we used to say : Russia, China and North Korea exist on completely separate spectrums.

This project will moon for sure.

Tail Call Optimization is an optimization done by the compile/vm that replace (in assembly terms) a CALL by a JMP. Therefore removing a call stack.

I have landed a new job recently and during the job search I also did statistics.

For context I am 30 year old french, had my one and only job for 6 years doing PHP (sf2, postgres, redis, solr, rest), I have a 2 year degree where in europe most people have a 3 to 5 year degree.

Here is my statistics to applying to ads on indeed:

France: - application: 40 - noreply: 20 - phone screen: 7 - interview: 3 - landed: 1

Luxembourg (french speaking): - application: 18 - noreply: 9 - phone screen: 5 - interview: 1 - landed: 1

Remote (europe): - application: 7 - noreply: 5 - interview: 0

Spain(5)/Portugal(2)/Uk(2)/Switzerland(1): - application: 10 - noreply: 1 - phone screen: 5 - interview: 3 - landed: 0

My takes over are:

- Cover letter doesn't increase my chances of having a reply.

- Changing my CV after the feedback of a recruiter (he asked me to lie by omission) didn't improved my chances.

- I don't apply to company I recognize the name. If I do lots of people do too therefor there is a lots of better candidates than me and the company can afford to run me through many interviews.

- I don't apply to company that do more than 1 interview, they have too much time on their hands to find a reason not to hire me.

- I don't apply to company that specifically ask for a 3 to 5 years degree even if I fit the rest of the requirements.

This last job search (the one that landed my first job 7 years ago wasn't a bliss either) made me feel extremely under-confident in my capacity to grow my career even having a job.

Robotics solutions targeting recycling https://zenrobotics.com/

I suspect english words starting with 'ph' come from french, french words with 'ph' used 'ph' instead of 'f' (same sound) to emphase the fact the word borrow greek root (but who care the word come from greek, does it make it easier to learn? one more shitty rule of french).

According to Mathew Flatt it will fasten racket.

https://www.youtube.com/watch?v=t09AJUK6IiM

As a French dropout (6 years of experience now), no degree = no jobs. And a lot of low job (CRUD) require Bac +5 ludicrous.

What the point in using VS Code compared to emacs when we have LSP servers and an emacs lsp-mode ?

I would use it to mine bitcoin and heat my house in winter, I already have a slogan :

"Don't be a patsy who pay for heating your place, be paid for it. Order our heating device for just $2999!"

https://github.com/danluu/debugging-stories https://github.com/danluu/post-mortems

Could you explain?

> Macros aren't required for reducing boilerplate and don't necessarily reduce boilerplate compared to a non-macro solution in an expressive language.

So i suspect you are thinking of ruby metaprogramming, in that case you have good and bad. With macro you can expand your code and have static tool reason about your code (IDE à la Éclipse). In the other hand in metra prog. you have all the info availlable at runtime and it is more easy to implement.

> I just don't like the difference that being able to cook up your match using macros makes a huge difference when it comes to programming productivity.

For the specific racket's match you can build your own match rule (http://docs.racket-lang.org/reference/match.html?q=match#%28...) and that is macro power..

In my own use of lisps i havn't realy used any macro.

> "Macros are a secret sauce"

It is probably an overstatement, if they have been useless for you (and me) doesn't mean they are.

The specific problem of wrapper around HTTP API have been resolved with WSDL (https://www.w3.org/TR/wsdl) assumming the use of WSDL the only thing a macro could do is equivalent of what an external program that generate a python file implementing the WSDL could do. I have written a php parser with the racket LLAR macro and it doesn't add more than an external tool like bison.

Reducing boilerplater could make your code less buggy (bugs you catch with your eyes) and could make the meaning of the code more clear.

Racket match is realy nice but it will shine if:

- You use a lot of immutable datasctructures.

- Explore shallow tree like data structures.

> and my personal opinion is macros are a meme

As far i has understand macro is already in use as Annotations for java.

In php, programmers developped complex frameworks that generate code (Symfony for instance) before running the user's code even if it isn't a macro per-se it share the same goal.

And i could have mention c++ template, so i don't think macro are a meme they already exists and there is a demand for it.

The example you give doesn't have boilerplate so macro can't do more.

Macro can help for two things:

- reduce boilerplate

- add new function to your language (often specific and limited in context of use [racket's macro a suposedly composable]). Example: racket match, clojure.async.

If i am not mistaken the salaries given for the US is what the company actually pays, but the salaries given for France it's not what the company pays. We (the french) discuss our salaries in 'brut' (gross) and are never aware of what we actually cost. The company will pays something (close) up to 42% more of this gross value. So i suspect the difference between US salaries and French (and probably german, uk) is unfair.

What is your setup working with gerbil compared to emacs/slime?

It works in geiser-mode, i don't know if it works with drracket or racket-mode.

http://docs.racket-lang.org/guide/eval.html?q=namespace#%28p...

What is your company?

It's common practice in Vatican Bank.

I think he mean that:

https://www.wellingtonnz.com/work/looksee-wellington/

Convolutionnal neural network (called IA in the news, will automate previously safe jobs)

Upgrade in hardware

Bitcoin technology (made it's way into traditionnal banking)

And if you want more thing into programming:

In the last 15 years the Racket team has came with contracts (something with high order function that didn't existed before), gradual typing which generate contracts, macro composition. None of them existed before.

I have used phantomjs (with casperjs) for scrapping a website, it was complete nightmare.

1. It use javascript to script so writting sequential code wasn't possible so the code ended up using continuation passing style.

2. The very first example snippet on the front page don't work in the repl (https://github.com/ariya/phantomjs/issues/11180). So the repl is useless.

3. When an error occur in your script (not the one on the webpage) there is no message anywhere no matter what you do.

My mistake was to continue with phantomjs the hype around made me think others options would have been worst.

I have used selenium+firefox+php to do a quick test it was wayyyy better, just for n°1 using sequential php remove a lot headaches.

Yes, but belgium and switzerland doesn't:

    France, belgium/switzerland
    70 -> soixante dix (60 + 10) -> septant (latin word like september for 7)
    80 -> quate vingt (4 * 20) -> octant/huitant (come from huit = 8)
    90 -> quatre vingt dix (4 * 20 + 10) -> nonant  (latin word for 9)

"If I lied, you are allowed to insult me abundantly through your favorite channel."

Haha racket can here is how.

    #lang racket
    
    (define (foo a [methods empty])
      (let ([methods
             (append methods
                     (for/list ([i (range 3)])
                       (lambda (x) (+ x i))))])
        (for/sum ([m methods])
          (m a))))
    
    (foo 0)  ;; Should be 3
    (foo 1)  ;; Should be 6
    (foo 2)  ;; Should be 9
    (foo 2 (list (lambda (x) x)))  ;; Should be 11
    (foo 0)
    (foo 1)
    (foo 2)


    ;; Now the wrong way

    ;; The lambda capturing wrong
    (define (foo a [methods empty])
      (define i 0)
      (let ([methods
             (append methods
                     (for/list ([z (range 3)])
                       ;; modifying the variable i
                       (set! i z) 
                       (lambda (x) (+ x i))))])
        (for/sum ([m methods])
          (m a))))

    ;; this one doesn't do the default parameter wrong, because
    ;; methods and methods-default share an imutable list and we
    ;; modify only methods so beside "empty" they won't share the same
    ;; reference anymore, to get it wrong we should use a mutable list
    ;; (doesn't exist in racket).
    (define foo
      (let ([methods-default empty])
        (lambda (a [methods methods-default])
          ;; (printf "~a ~a\n" (length methods) (length methods-default))
          (define i 0)
          (for ([z (range 3)])
            (set! i z)
            (set! methods (cons (lambda (x) (+ x i))
                                        methods)))
          (for/sum ([m (append methods methods-default)])
          (m a)))))

    ;; So i use a box to make it mutable.
    (define foo
      (let ([methods-default (box empty)])
        (lambda (a [methods methods-default])
          ;; (printf "~a ~a\n" (length (unbox methods)) (length (unbox methods-default)))
          (define i 0)
          (for ([z (range 3)])
            (set! i z)
            ;; methods and methods-default share the same reference of box.
            (set-box! methods (cons (lambda (x) (+ x i))
                                    (unbox methods))))
          (for/sum ([m (unbox methods)])
            (m a)))))

The moral of the story, language design matter, immutable by default is good, lexical scoping is good, binding over variable is good, ruby, python, php and javascript (the languages the author mention) are bad in that regards.

One thing php, ruby, python (but not javascript) has good over racket their identatation tend to be flat and racket (let form, no return statement) tend to go all the way to the right.

Can't wait for taste-o-vision and stop the cooking when it taste good.