Hacker News new | past | comments | ask | show | jobs | submit | PyComfy's comments login

From the same website:

Iconic yachts: On board Steve Jobs's Feadship superyacht Venus

https://www.boatinternational.com/yachts/editorial-features/...

Jobs died before it was finished.


34yo here, got called a cheater constantly, even by "top" players. Despite using a slow sensitivity myself, i would say that slow/fast sensitivity or wrist/arm aiming doesn't matter; I have seen plenty of people being very efficient with each technique. Just use what you are the most comfortable with. Something specific that tremendously helped me is putting fingers on each side of the mouse to lift it a little, the mouse is no more touching the mousepad, only your fingers, that way i can stop moving much more precisely. You no more think about aiming with the mouse but with your hand. When i need a slower sensitivity, i just lift the mouse higher. In the past i was playing with a CRT monitor at 160hz, now i am playing with a IPS monitor at 144hz (LG 27gl850-b); i have seen no difference in performing at KovaaK aim trainer[1]. Something that actually made a difference is where the sensor is located under the mouse. More the sensor was toward the back of the mouse (toward the wrist), more my aim was degrading. I also once tried a vertical mouse (Trust GXT 144) and did my best score ever in tracking, it was like holding a pen.

[1] https://store.steampowered.com/app/824270/KovaaKs/


http://www.buildyourownlisp.com/


Intel shall definitively be worried

https://blog.cloudflare.com/arm-takes-wing/


for linear algebra, may i add http://immersivemath.com/ila/index.html


http://lodev.org/cgtutor/raycasting.html

~200 LOC


Is it really? If we go back to the roots, lisp is made of what John McCarthy calls the Primary S-Functions which are atom, cons, car, cdr, and eq (a.k.a =). Of these five, clojure only has two (atom and eq)


> Of these five, clojure only has two (atom and eq)

You can't have atom without conses (well, it would just be (lambda (x) t)); which Clojure function are you thinking of?


Clojure has an ATOM function, but it does something completely different from Lisp's ATOM function.


Does Graal support tail call optimization? It has been announced for hotspot +10 years ago but still not implemented as today.

edit: https://blogs.oracle.com/jrose/tail-calls-in-the-vm


When executing on Java we are dependent on hotspot to support it in the native bytecode interpreter. In truffle interpreters we made some successful experiments with tail calls emulated using exceptions. It's pretty slow in the interpreter but as soon as graal optimizes it, it just turns into a tailcall loop. Here is some more info: http://epub.jku.at/obvulihs/content/pageview/508465

You may find some blog posts about truffle and tailcalls as well.


You may see support for tail calls added as part of project loom.


Naive interpretation of the bytecode (not even pre-decoded, just a switch statement). And almost everything is resolved in the dynamic environment. for example,

    a = foo.bar(b)
is actually

    ldict = locals()

    ldict['a'] = ldict['foo'].__getattribute__('bar')(ldict['b'])


This is a bit misleading. You suggest that local variables are looked up by name in a dictionary, which is not the case. They are looked up by indexing into a C array, with the index being a constant in the bytecode. That's quite a lot simpler. Here is the corresponding code (look above for the definition of the GETLOCAL macro): https://github.com/python/cpython/blob/fc1ce810f1da593648b4d...

So your code should be more like:

    locals[a_idx] = locals[foo_idx]->__getattribute__('bar')(locals[b_idx])
But this isn't a very good rendering of the thing because it doesn't show the many redundant reference count increment/decrement pairs every time you touch a variable.

(Also, interpreter dispatch uses computed GOTOs instead of the plain switch on C compilers that support it.)


ah sorry. i did

    import dis
    dis.dis("a = foo.bar(b)")
which gave

    1           0 LOAD_NAME                0 (foo)
                2 LOAD_ATTR                1 (bar)
                4 LOAD_NAME                2 (b)
                6 CALL_FUNCTION            1
                8 STORE_NAME               3 (a)
               10 LOAD_CONST               0 (None)
               12 RETURN_VALUE


Ah, OK. Yes, those LOAD_NAMEs are slower than LOAD_FAST. If you put the code into a function, you get this:

    >>> def f(foo, b):
    ...     a = foo.bar(b)
    ... 
    >>> dis.dis(f)
      2           0 LOAD_FAST                0 (foo)
                  3 LOAD_ATTR                0 (bar)
                  6 LOAD_FAST                1 (b)
                  9 CALL_FUNCTION            1 (1 positional, 0 keyword pair)
                 12 STORE_FAST               2 (a)
                 15 LOAD_CONST               0 (None)
                 18 RETURN_VALUE
LOAD_FAST is the normal case for locals inside a function. Not sure off the top of my head where LOAD_NAME would be generated in normal usage (i.e. where you don't evaluate code from a string).

Edit: Also, I'm talking about Python 3. Maybe you aren't.


Interesting experiences beyond the command line are game development tools; Each iteration try to make the barrier between artists/content creators and programmers thinner.

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


Indeed. Also interesting is a look at games themselves, especially those that show a long trajectory from beginner to experienced player with significantly different interaction patterns between the two groups.

It would seem that practically no programmer's tool has ever received the attention to interface detail that is common in the best games.


Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: