Lisplog

Feed Aggregator Page 651

Rendered on Sun, 27 Sep 2020 20:33:25 GMT  newer latest older 

Can the compiler skip virtual DOM?

via Elm - Latest posts by @evancz Evan on Sun, 27 Sep 2020 14:25:46 GMT

No problem! I think Svelte was saying “faster than virtual DOM” in a lot of their public communication, so I think many people have this impression.

My understanding is that they knew Elm had similar perf numbers to them, but they assumed Elm must be using the same techniques. I told them that was not the case in June 2019 so hopefully they saw it and changed how they talk about things since then

Elm in a nutshell

via Elm - Latest posts by @Laurent Laurent Payot on Sun, 27 Sep 2020 07:56:15 GMT

To a non-technical person:
Less bugs, lower maintenance cost, no fear of changing things. And eventually (at least at NoRedInk) easier recruiting, of better coders who are reluctant to “foot-shooting” programming styles.

Discussion: How much to pipeline

via Elm - Latest posts by @opsb Oliver Searle Barnes on Sat, 26 Sep 2020 11:34:26 GMT

My rule a thumb is

For non view code:

• Use <| or parens for one liners
• Use |> when more than 1 function is applied to a value

For view code:

• Favour <| for building html hierarchies (I like the code to fit the html structure as far as possible)
• Only use |> when assigning values in let blocks, never in the body of the let or any other expressions. Put another way, I only use |> to calculate values which are then used to express the html.

Discussion: How much to pipeline

via Elm - Latest posts by @lydell Simon Lydell on Sat, 26 Sep 2020 09:39:02 GMT

I only pizza if there are two or more values in the chain

I think error messages are better when you do someList |> List.map (\item -> whatever) rather than List.map (\item -> whatever) someList. It’s almost always the lambda that is wrong so I like when it is marked as the error rather than someList.

-- TYPE MISMATCH - src/Example.elm

This function cannot handle the argument sent through the (|>) pipe:

182|     someList |> List.map (\( _, x ) -> x + 1)
                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
The argument is:

    List number

But (|>) is piping it to a function that expects:

    List ( a, number )

Hint: Only Int and Float values work as numbers.

-- TYPE MISMATCH - src/Example.elm

The 2nd argument to `map` is not what I expect:

186|     List.map (\( _, x ) -> x + 1) someList
                                       ^^^^^^^^
This `someList` value is a:

    List number

But `map` needs the 2nd argument to be:

    List ( a, number )

Hint: I always figure out the argument types from left to right. If an argument
is acceptable, I assume it is “correct” and move on. So the problem may actually
be in one of the previous arguments!

Hint: Only Int and Float values work as numbers.

Can the compiler skip virtual DOM?

via Elm - Latest posts by @Naserdin Naserdin on Sat, 26 Sep 2020 04:52:16 GMT

Hi, Evan, thanks for this detailed explanation, surprised me! I naively thought precise dom manipulation is better than virtual DOM diffing update. seems like svelte has some advantages over other freamwork, and it’s all due to the compile process. so this question just came to my head. I think you are right, performance is not a big deal to most people because the hardware nowadays is to good to let user perceive the difference between freamworks. as a developer, it’s easy for me to just think about something is maybe can bring performance benefit. You maybe thought about is too before. so hey, keep up your good work, I like Elm, hope it will become more widely used.

Discussion: How much to pipeline

via Elm - Latest posts by @brian Brian on Fri, 25 Sep 2020 20:23:30 GMT

I follow a few rules since it’s so easy to get overzealous with pipelining. I’m gonna call these pizza rules here for fun.

1. I only pizza if there are two or more values in the chain
2. If the code is short enough to be subjectively fine on one line, I get suspicious and probably will refactor it to use parens
3. I try to never pizza in HTML code[1]
4. I never use left pizza except when I’m avoiding parens around a function (in, say, elm-test tests)

[1]: I gave a talk at Elm in the Spring where I recommended people do that and now I kinda regret making such a strong recommendation! I think it’s fine but the HTML-like pattern is fine and has well-understood syntax and semantics such that it’s maybe a better pattern. Still depends highly on the team.

Quicklisp news: September 2020 Quicklisp dist update now available

via Planet Lisp by on Fri, 25 Sep 2020 19:40:00 GMT

 New projects: 

• cl-base16 — Common Lisp implementation of base16 — GPLv2
• cl-bcrypt — Common Lisp system for generating and parsing of bcrypt password hashes — BSD 2-Clause
• cl-getx — This is a naive, persisted, in memory (lazy loading) data store for Common Lisp. — MIT
• cl-indentify — A code beautifier for Common Lisp. — MIT
• cl-kaputt — A Simple Interactive Test Framework for Common Lisp — MIT
• cl-mango — A minimalist CouchDB 2.x database client. — BSD3
• cl-minify-css — To minify css with common lisp. — GPLv3
• cl-rfc4251 — Common Lisp library for encoding and decoding data in RFC 4251 compliant format — BSD 2-Clause
• cl-setlocale — FFI to setlocale and ncurses locale helper — 2-clause BSD
• cl-ssh-keys — Common Lisp system for generating and parsing of OpenSSH keys — BSD 2-Clause
• cl-wave-file-writer — A wave file writer — MIT
• class-options — Provides easy access to the defining class and its options during initialization. — Unlicense
• compatible-metaclasses — Validates superclasses according to a simple substitution model, thereby greatly simplifying the definition of class mixins. — Unlicense
• enhanced-find-class — Provides a canonical way of converting class designators to classes. — Unlicense
• evaled-when — Provides a way of extracting and replicating the compile-time side-effects of forms. — Unlicense
• file-attributes — Access to file attributes (uid, gid, atime, mtime, mod) — zlib
• gadgets — Ben McGunigle's utility collection — Apache License, version 2.0
• gooptest — A microcontroller testing framework. — GPL-3.0
• kekule-clj — A Kekule widget for Common Lisp Jupyter — MIT
• magicffi — cffi interface to libmagic(3) — Simplified BSD License
• math —это математическая библиотека, реализующая некоторые алгоритмы: - линейной алгебры; - операций работы с матрицами; - статистические функции; - линейной и билинейной интерполяции; - нахождения приближающих многочленов, реализованная на Common Lisp — GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007 or later
• messagebox — A library to show a native message box dialog. — zlib
• metalock — A metaclass that makes building parallel systems easier by providing each slot within a class a lock which is grabbed automatically. — MIT
• nbd — Network Block Device server library. — MIT
• object-class — Ensures that special subclasses of standard-object cluster right in front of standard-object in the class precedence list. — Unlicense
• picl — Python Itertools in Common Lisp — MIT
• pkg-doc — View package documentation in a clim-treeview — BSD Simplified
• py4cl2 — Some improvements over py4cl — MIT
• shasht — JSON reading and writing for the Kzinti. — MIT
• simple-guess — Defines a simple extensible protocol for computing a guess using advisors. — Unlicense
• trivial-do — Looping extensions that follow the style of the core DO functions. — MIT
• uncursed — Another TUI library, this time without curses. — BSD 3-Clause
• xcat — XCAT mass LAN big file distributor — MIT
• zippy — A fast zip archive library — zlib

Updated projects: 3b-hdr, 3bmd, acclimation, alexandria, algae, anypool, april, atomics, babel, bdef, bst, ci-utils, city-hash, cl-all, cl-aristid, cl-autowrap, cl-base64, cl-bnf, cl-cffi-gtk, cl-collider, cl-conllu, cl-covid19, cl-dot, cl-erlang-term, cl-fix, cl-forms, cl-fuse, cl-gamepad, cl-gserver, cl-html-parse, cl-kraken, cl-liballegro, cl-liballegro-nuklear, cl-markless, cl-migratum, cl-mixed, cl-mpg123, cl-naive-store, cl-patterns, cl-png, cl-pslib, cl-rabbit, cl-readline, cl-redis, cl-renderdoc, cl-rrt, cl-rsvg2, cl-sdl2-ttf, cl-steamworks, cl-stomp, cl-store, cl-str, cl-unification, cl-utils, cl-webkit, cl-zyre, clack-pretend, clast, clawk, clcs-code, climacs, clj, closer-mop, clunit2, com-on, com.google.base, common-lisp-jupyter, commonqt, croatoan, deploy, diff-match-patch, djula, easy-audio, easy-routes, eazy-process, eclector, eos, exscribe, f2cl, fare-quasiquote, fast-io, file-select, fiveam, flare, flexi-streams, flexichain, float-features, font-discovery, fset, functional-trees, gendl, generic-cl, glacier, glsl-toolkit, golden-utils, gtirb, gtirb-capstone, harmony, hu.dwim.asdf, hu.dwim.delico, hu.dwim.walker, hunchentoot-multi-acceptor, hyperluminal-mem, hyperobject, inferior-shell, inner-conditional, ironclad, jingoh, jonathan, jpeg-turbo, kmrcl, lazy, linear-programming, lisp-binary, lisp-gflags, lispcord, literate-lisp, local-time, log4cl, maiden, markup, mcclim, method-hooks, mgl-pax, modf, mutility, named-readtables, nibbles, nodgui, null-package, opticl, origin, osicat, overlord, paren6, parse, pathname-utils, perceptual-hashes, petalisp, phoe-toolbox, pngload, portable-condition-system, postmodern, protobuf, psychiq, py4cl, quilc, quux-hunchentoot, random-state, read-as-string, replic, roan, rpcq, s-graphviz, sanity-clause, sc-extensions, scalpl, sel, serapeum, shadow, sheeple, shellpool, simple-actors, slime, sly, snooze, stumpwm, sxql, tooter, trace-db, trivia, trivial-arguments, trivial-clipboard, trivial-custom-debugger, trivial-garbage, trivial-gray-streams, trivial-utf-8, trucler, uax-14, umbra, unix-opts, vernacular.

Removed projects: unicly.

To get this update, use (ql:update-dist "quicklisp").

Enjoy!

Discussion: How much to pipeline

via Elm - Latest posts by @Lucas_Payr Lucas Payr on Fri, 25 Sep 2020 16:33:42 GMT

Personally, I love to use the |> pipe as much as possible, even in the view.
Something like

items
    |> List.map viewItem
    |> Element.column [ Element.spacing 8 ]

Seems very normal to me.

I also use <| but rather rarely, trying to keep it at a minimum. I try to use it only for math or for type conversion:

Element.spacing <| toInt <| 17 / 4

Elm in a nutshell

via Elm - Latest posts by @eimfach Robin G. on Fri, 25 Sep 2020 14:45:34 GMT

Hi Folks !

I was wondering on how to think, write and tell about elm holistically. How would you think, write and tell about Elm to someone completely unaware of technological topics or someone who is not too much experienced with programming or comes from another perspective of programming ?

I think of things like:

• What is Elm ?
• How does it work ?
• What are the Pro’s and Con’s ?
• How to you get deeper into it ?
• Are there challenges ?
• How does it evolve in simple terms ?
• What do you think about it’s future ?
• Is it more than just about programming ?
• What are the principles of Elm ?
• How do you keep an overview of it’s resources and which resources are actually helpful ?
• How to you introduce and learn advanced Elm topics simply ?
• How does one participate in the development of Elm ?
• What does organic advancement mean in terms of Elm ?
• Where to find a central Resource of Documentation either from community or official ?
• What can Elm do from a Business perspective ?
• What about the Web APIs in Elm ?
• Where can you find scaffolds for your Elm project ? (e.g. the default architecture, games, packages…)
• How does the community make impact on elm development ? Can it ?
• How to keep and overview of different useful Patterns in Elm ? Even if you are not working with it day by day ?
• Which Elm Meetups exist and where can I join ?
• Which conferences are planned and how can I attend ?

Parsers with Error Recovery

via Elm - Latest posts by @rupert Rupert Smith on Fri, 25 Sep 2020 08:50:07 GMT

I tried to keep the API idential to Parser.Advanced, so switching over to it should be relatively easy. All the functions should behave the same way as the corresponding functions in Parser.Advanced. The behaviour should only change when you apply one of the recovery tactics.

I cannot export (|.) and (|=) though, due to kernel code restrictions :-(. So you have to re-write those:

import Parser.Advanced as PA exposing ((|=), (|.))

parser = 
    PA.succeed identity
        |. PA.spaces
        |= PA.int
        |. PA.spaces

to

import Parser.Recoverable as PR

parser = 
    PR.succeed identity
        |> PR.ignore PR.spaces
        |> PR.keep PR.int
        |> PR.ignore PR.spaces

Another difference is that where functions like Parser.Advanced.keyword take a Token argument, I thought just passing in the String and problem without wrapping as a Token was neater:

PA.keyword (PA.Token "let" ExpectingLet)

PR.keyword "let" ExpectingLet

I’ll likely make a release soon - I’m trying to figure out how to make a recoverable version of sequence first. The fast-forward recovery at the moment fast forwards to a sentinal Char, then continues. But sequence uses Strings as separators not Chars, so I need to implement a slightly different fast-forward mechanism, then it will be good to go. I’ll just push it out with the recovery tactics I implemented so far, it will be interesting to hear if they work for you, or if you find they need to be modified to cover situations you are encountering.

 newer latest older