unicin, c'est de prendre un fresh look
à
vous savez, à la programmation
et voir si
il y a de la chose qu'on fait
de la change
de l'application
des langues
ou de la programmation
afin de
faire plus de ceci et de
faire cela délice.
Réveillez, le tout l'épisode est seulement disponible
pour nos membres de notre Patreon.
Bonjour, bienvenue à la podcast de DevTools FM.
C'est un podcast sur les tools de développement
et les gens qui les font.
Je suis Andrew et je suis mon co-host Justin.
Salut tout le monde.
J'ai vraiment hâte de vous avoir regardé
un de mes co-founders de unicin.
Unicin est un langage de programmation
qui sera notre topic aujourd'hui.
J'ai vraiment hâte de vous parler.
On l'a mentionné plusieurs fois sur le podcast
dans le passé.
Mais,

avant de nous parler,
Runaar, vous voulez dire hello à l'audience
et vous dire à nous de vous parler ?
Salut, je suis glad d'être ici.
Je suis Runaar.
Je suis un de mes co-founders de unicin de computing
qui fait unicin,
qui est un langage de programmation
et une plateforme de développement
en plus pour
les systèmes distribués.
Mais c'est
un langage très unusual
avec beaucoup de
cool features.
On appelle ça
un langage de programmation friendly
de l'avenir.
Parce que,
numéro un,
ce n'est pas
complètement au présent,
parce que c'est pas
où nous voulons être.
Mais aussi,
nous pensons que c'est où
le programme va
dans le futur.
Oui,
Unicin
semble être un de ces langages
où,
à chaque fois qu'il y a une conversation
sur le futur de programmation,
c'est le langage
qui vient de venir.
Et
il y a beaucoup de
features
qui font
cela
différent.
Vous voulez essayer de donner
un
vue de 50 000 foot pour nos listeners
de ce que ce sont les choses
qui font Unicin
le langage de programmation ?
Oui,
donc,
c'est purement fonctionnel
et c'est donc un peu un peu


un peu
il y a beaucoup de choses
qui sont
un peu
un peu
pas d'habitude,
mais aussi des langages
comme Askel
ou Smalltalk
ou autre.
Mais le truc qui fait
Unicin
complètement différent,
je pense,
de toute la langue,
c'est
deux choses.
N°1,
le code
n'est pas texte,
c'est
une structure immutable.
Donc,
votre base de code
est
littéralement un database
qui vit
sur votre
disc
ou dans le cloud,
ou quelque chose.
Et puis,
la autre partie de ceci
est que
le code
est
des adresses de contenu.
C'est-à-dire
que nous n'y refaitons pas,
donc,
sous la coude,
Unicin ne refait pas
des dépendances
de
les fonctions
et des types
par leurs names,
ou comme,
les names-papers,
ou quelque chose.
Il utilise
un hash
de la programmation.
Donc,
il y a vraiment
comme
chaque piece de code
a un adresse
globale
unimpigueuse
dans le sort
d'un adresse infinit.
Cool,

Donc,
est-ce que le hash
est basé
sur le
forme actual
de la
chose?
Donc,
si deux gens
ont écrit
deux fonctions
qui sont
en fait
les mêmes
et les hautes,
ils
ont réparti
les mêmes hautes
théoriquement?
Oui,
donc,
le hash
est
récomputé
par,

de remettre les names
et de replacer
les names
avec les
joueurs.
Et,
on
remet les
names locales
et tout comme ça.
Et,
on
juste
hash
le syntaxe
de la

Donc,
si vous
avez écrit
une fonction
qui
fait
la même chose
que
une fonction
d'autre,
ça peut avoir une hache
car votre implementation
sera un peu différente.
Mais,
si c'est
vraiment la même
implementation,
comme le modulo
les names,
ou comme
l'intentation
ou quelque chose,
alors,
c'est,
c'est un peu
la même hache.
Et,
juste le jour
que je faisais
une fonction,
j'étais comme,
j'aurais mieux ajouter
cette fonction
au base,
parce que c'est super utile.
Et,
je vais ajouter
une fonction,
c'est comme,
j'ai glissé
cette fonction pour vous,
mais,
il y a aussi cet autre nom.
Et,
j'ai dit,
ok,
quelqu'un a déjà écrit ça.
Et,
c'est un effecteur
de l'envers
de la façon
fonctionnelle,
parce que c'est,
vous faites
ces choses
très generiques,
réusables,
et,
ça,
ça peut juste se passer,
parce que vous faites
des petites unes
de la programmation.
Oui, c'est vrai.
Cette situation,
où vous avez la même
hache, c'est beaucoup plus
probable d'être
en train de venir,
et,
très abstract,
comme,
vous savez,
vous êtes,
vous savez,
comme,
intervier un liste
qui ne vous intéresse pas
de type,
ou de polymorphique,
de type,
et,
généralement,
des choses qui sont
réusables et ne sont pas
d'effectifs.
Mais,
même les choses qui ont
d'effectifs,
elles ont toujours
des haches.
C'est quelque chose
que j'aime,
et que je suis content
d'un système d'adresse
et que ça signifie
que les renomances
sont, comme,
fréquent,
vous pouvez renomber
tout,
et il n'y a,
finalement,
presque aucun conséquence
de faire ça.
Oui, c'est vrai.
Donc,
les renomances sont
vraiment juste de metadata
sur le,
sur le code base.
Et donc,
le code base
est un gros table de hache,
vous savez,
c'est un map
de haches
à la code,
et puis,
on peut attaquer
toutes les autres choses
sur le,
sur le,
vous savez,
sur l'entrée,
les choses comme,
que sont les names
pour cette chose.
Et vous pouvez avoir
beaucoup de names
que vous voulez
pour une fonction.
Comme,
j'aime,
vous savez,
l'optionale type
où c'est comme,
c'est peut-être présent ou pas.
Comme,
dans mon code base,
j'aime l'enlever,
peut-être,
si d'autres gens
l'aiment l'enlever.
Et donc,
j'ai juste un petit library
qui a juste les names,
qui sont mes préférances.
Et,
comme,
j'ai un nom renommé,
quelqu'un renommé
fold right.
Il s'est appelé fold R.
Et j'ai dit,
non,
non,
c'est deux sortes d'obscur.
On s'appelle fold right.
Et donc,
on renommé le base library.
Et,
personne ne s'arrête pas,
tout ça,
ça marche encore,
parce que tout ça,
tout ça,
c'est tout par hash.
Comment,
ça manifeste,
je veux dire,
les issues de communication
qui s'appliquent,
par le fact que les choses
peuvent avoir différentes names,
et ça ne peut pas être nécessairement,
je veux dire,
je sais que vous avez des signatures
pour tout,
mais,
c'est un truc de la même manière,
c'est un truc de la même manière,
mais,
oui,
ça peut arriver,
que,
quelque chose se fait,
et puis,
vous allez,
vous arrivez pour la librairie,
et vous êtes,
oh,
où est-ce que cette fonction,
qui était ici,
dans la dernière version,
et puis,
c'est,
c'est renommé.
Mais,
vous savez,
unique,
ça fait la histoire,
de tout ça,
donc vous pouvez aller,
dans la histoire,
et voir,
où les choses,
où,
ont changé,
et des choses comme ça.
Et,
vous pouvez,
vous pouvez avoir un nom historique,
pour quelque chose,
et aller,
et aller,
donc,
c'est,
l'histoire,
c'est,
c'est un peu janky,
mais,
on espère,
dans le futur,
que,
on peut faire cette expérience,
vraiment,
bien,
ça me rend penser,
de quelque chose,
qui est,
assez,
relative,
c'est,
donc,
si vous jouez avec unison,
je pense que vous pouvez,
vérifier,
les choses,
pour,
si vous voulez,
mais,

la code est,
dans un database,
comme vous avez dit,
donc,
c'est comme,
que l'expérience,
qui arrive,
très différente,
vous parlez de histoires,
donc,
qu'est-ce que,
que l'expérience,
que votre code,
dans l'Unison?
Oui,
donc,
l'Unison,
le manager de la code,
c'est un,
ce,
ce qu'on développe,
et ça,
c'est le,
qu'on fait,
de,
vous savez,
de,
de,
d'autres choses,
et,

car notre code n'est pas texte,
on ne peut pas utiliser le,
de,
on,
vous savez,
on a utilisé le,
dans le passé,

juste,
pour,
les bases de code,
sur le GitHub,
mais,
c'est un grand,

de,
de,
de,
de,
de,
dans le,
dans l'Inside of it.
Mais,
le manager de code,
il a,
le sort de,
structure de,
et c'est aussi,
le,
le,
il contient les spaces name,
et,
il y a un,
c'est un,
sur le spaces name,
où les spaces name,
peuvent avoir des branches,
et,
ça,
vous pouvez,
foregrounder le,
un spac d'un autre,
un espace name,
et puis,
et faire des travail là-bas.
Et puis, quand vous êtes prêt à travailler,
vous pouvez le remettre en bas à votre main de namespace.
C'est assez flexible dans ce regard.
Mais comme tout namespace fait la toute histoire de ce namespace.
Et le namespace a un hash.
C'est comme ça qu'il y a une histoire de tous les hash.
C'est le namespace.
Et oui, une collaboration s'occupe d'un namespace qui s'occupe d'un autre.
Et puis vous pouvez les remettre.
J'ai bien écouté le namespace.
Oui.
Je pense que c'est un concept très différent.
Vous avez un compiler qui te rend,
et puis une execution.
Avec Unison,
c'est comme si vous avez la construction de votre travail
par le namespace.
Vous pouvez expliquer ce qu'il y a
et les différentes choses que vous utilisez.
Oui.
Oui, en plus de langues, vous avez un grand baguette de textes mutables.
Vous procédez de muter vos textes et vous le permettez à un compiler, si c'est un langue compiler.
Évidemment, si vous travaillez dans une langue interprétée, c'est pas de l'appli.
Mais, en fait, en unissant, vous en faites en général un buffer,
donc vous travaillez dans un seul texte file.
Je fais un couple de textes files que je travaille dans et je continue de transmettre ces files au manager de code.
Et la façon dont ça fonctionne, c'est que vous regardez tout ce que vous avez commencé dans le directory.
Et puis vous travaillez sur un file avec une extension .u.
Si vous avez envoyé un file comme ça, le manager de code unicent de code, le UCM,
va vous réveiller et vérifier ce file et prendre des définitions que vous avez mises là-bas.
Et si ça n'a pas les données déjà dans le code base,
vous pouvez ajouter ces données.
Donc, il y a des commandes de l'UCM pour ajouter, éditer et retirer des définitions,
pour les types et les fonctions.
Et donc, le workflow, vous faites des petites changements dans un seul buffer,
et puis vous vous soumettez que vous travaillez dans un Git et vous faites un commit constantement,
comme chaque changement que vous faites.
Mais l'option de ceci est que votre code base est toujours dans un state de travail.
Vous...
Non, ce n'est pas...
Ok, c'est vrai.
Mais vous ne pouvez pas le détruire, mais vous pouvez le mettre dans un state où les choses peuvent être ambigües.
Par exemple, quelque chose peut être référencié à un autre hash que vous voulez.
Vous avez changé la définition d'un nom,
mais ça ne peut-être pas changer partout.
Mais le code base manager t'a toujours essayé de vous tourner.
Il y a un commande qui vous dit que vous avez un conflit de nom,
et vous avez le droit de résolver.
C'est un différent workflow,
de la plus grande partie.
C'est cool, le design de l'UNISM donne toutes ces propres intérêts.
Il y a beaucoup de défis avec la source control,
de l'utilisation de Git,
et de l'assistance de l'onis,
car la langue est tellement différente.
Le compte est adressable, il est stored dans le data.
Mais il y a aussi des traitements de la zone.
Vous devez construire une expérience qui n'est pas de Git,
mais d'une sorte de choses où vous êtes contribuant,
et que vous avez des versions,
et que vous faites des choses derrière les scènes.
Et puis, en pensant,
il y a des choses uniques,
où les gens qui sont vraiment utilisés
pour les browseurs sur le système de file,
peuvent trouver ça un peu plus difficile
de dire, comment j'ai de la browse à UCM
pour voir ce que le code existe,
et tout ça.
C'est comme,
qu'est-ce que vous faites pour la histoire
d'exprimer votre code base
et d'understand ce que c'est écrit,
et tout ça.
Oui, vous pouvez browser
en utilisant UCM,
mais c'est beaucoup comme
en utilisant la ligne de commande
pour browser un système de file.
Mais il y a aussi un UI,
donc si vous type UI
dans UCM,
ça va vous donner une interface
dans votre browser,
que vous pouvez utiliser pour browser votre code base
et voir ce que le code est là,
et recréer la documentation,
et des choses comme ça.
Et ça a la même interface
que la Unison Share.
Unison Share est un hub
où vous pouvez ouvrir
la code,
collaborer et partager votre code avec les autres.
Oui, donc on va se dérouler
plus en plus.
Je suis en train de browser
des pages de share,
et c'est vraiment intéressant
que vous pouvez...
C'est une documentation de full-fledged,
il y a des exemples de tournage,
vous pouvez se dérouler
et voir le code actuel.
Tout est hyperlincé,
c'est une expérience très intéressante.
Pour une personne qui ne sait rien,
est-ce que la documentation est construite
dans la langue,
et est-ce que la Unison encourage
vous d'en documenter?
Oui, on ne vous encourage pas
d'en documenter,
mais on devrait probablement
essayer de faire ça.
Mais oui, la documentation
est en unison.
Unison a un syntaxe
où
vous vous dites un expression
d'un document, vous ouvrez avec deux bras
et c'est un syntaxe
comme un syntaxe, mais c'est juste un sugar
syntaxe pour un expression unisan
qui appelle des fonctions.
Et ce que vous buildez
c'est un valeur de ce type
d'un type doc
et un share unisan
et le local UI aussi.
Ils ont
des rendeurs pour ce type,
donc vous pouvez juste aller
et
vous regardez un doc,
il va le rendre en un code
qui est assez html.
Et si vous vous mettez un code
comme des exemples de code,
vous mettez un triple
un code de Bactics
ou autre, et vous pouvez mettre un code exemplaire.
Et
ce code que vous vous mettez
sera
un code live.
Et donc,
tout est refermé par hash
et donc toutes les
définitions ou les dependencies de ce code
vont être hyperlinks
à la hash
que vous êtes refermée. Et vous pouvez cliquer sur ça
et voir la définition de ça.
Quoi, juste comme
ça me dérange toujours
à chaque fois que je visite unisan.
C'est comme comment ambitieux le projet est,
comment beaucoup de choses que vous avez
faits
dans l'ensemble de la langue
et le service shared.
Je sais que il y a probablement
encore beaucoup de travail à faire,
mais c'est un
grand shift de paradigm
et je ne sais pas, je suis
comme un idiot parce que c'est la plus cool chose.
Je veux juste
arrêter et demander
une question de métal.
Pourquoi vous avez fait tout ça?
Qu'est-ce qui vous inspirez à prendre
ce path?
Oui.
Utter insanity.
Maintenant,
c'est
donc, la
foudre,
nous qui travaillons en unissant la compétition,

nous avons
programmé depuis le 80
ou le 90.
Et
programmation est
comme, je ne sais pas, quand vous commencez
à faire des programmes, c'est
comme, délite, et amusant,
et c'est une expérience exhilarée.
Et puis vous allez au
le monde réel avec vos skills
et vous voulez construire les systèmes réels.
Et il se trouve que les systèmes de building
sont terrible et délicieux.
Et les tools que vous avez pour ça
sont
comme,
comment
vous déploiez un service
dans une place de cloud infrastructure
ou quelque chose. C'est ce genre de
choses que vous avez besoin de faire.
Et comme, comment vous le faites, c'est
comme, un peu de bullshit.
Vous ne vous utilisez pas
la langue de programmation
pour parler de
les processus que vous vous
avez de vous faire communiquer.
Vous savez, comme je
travaillais dans une grande corporation
sur la côte du West
et je
faisais

protocoles
qui utilisent Jason et
Parc, des choses qui ont
dû aller entre les services micros, et je
faisais comme, comment je fais, c'est
un waste de mon temps. Et comme
tout le monde, et c'est comme, je ne sais pas, 80%
ou 90% de tout le monde, c'est
comme, c'est fait.
C'est été expérimenté, comme,
en écrivant
la sort de la plate de boiler,
sans sens, qui n'est pas
dans la langue de programmation.
Et donc,
le, le, le
goal, ou, vous savez, ce qu'on a
voulu avec unison, c'est de
prendre un fresh look
à
vous savez, à, à, à
programmation, et voir
si, est-ce qu'il y a
quelque chose de change
de, vous savez, de
comment les langues de programmation
travaillent, ou comment la programmation
travaille, et que
on puisse, vous savez, faire
plus de ça et le faire
délire. Et donc,
ce que j'ai voulu
c'est de pouvoir, comme, faire un programme
qui décrit, comme, mon système
et, puis,
faire ce programme, c'est de déployer
Et c'est ce que nous essayons de faire avec Unison Cloud.
Oui, donc en parlant de Unison Cloud, un des features de Unison,
ou je pense deux features de Unison, vous avez cette notion de la première classe de distributed computing.
Vous avez un exemple sur votre site qui ressemble à un sparkjob,
où vous faites un gros maître de processus différents, un gros set de données.
Et puis vous avez une solution de distribution de storage.
Je n'ai pas fait trop de ça, et peut-être vous pouvez nous parler un peu de ça.
Mais une des questions que j'avais sortie de ce qui est de la question,
c'est que vous vous faites juste de la pensée du fondamentale,
de la façon dont vous approchez de la langue de building a programming.
Et c'est beaucoup de travail.
Et puis vous êtes aussi en train de faire un monde très harribé de systèmes de distribution.
Je voudrais vraiment entendre plus de systèmes de distribution,
mais aussi pourquoi est-ce que ce problème, en particulier,
est quelque chose que vous vous ajoutez à ce point ?
Je pense que ça va retourner à ce que vous avez dit avant,
que vous vouliez juste de construire des systèmes.
Oui, c'est la nature du base,
que quand vous allez au monde réel et vous faites un programming,
vous n'êtes généralement pas le code de la writing
qui parle juste de ce que l'une machine fait.
Je pense que dans l'époque de la software shrinkwrap,
et de la fois que certains programmers sont délice,
ils sont là, ils font des programmes que ils vendent.
Mais beaucoup de nous sommes dans les systèmes de building
qui ont beaucoup de services différents,
qui ont besoin d'un autre.
Ils sont des systèmes distribués.
Je veux dire que même le programme client-server,
le programme de la back-end browser,
est aussi un programme distribué.
Nous sommes toujours construits dans les systèmes
où les choses doivent parler de l'un à l'autre.
Et à cette boundary,
où vous vous en prenez une machine
et vous devez parler d'un programme
qui se déroule sur une autre machine,
il y a un mismatch d'impedance.
Il y a tout ce travail que vous devez faire
pour faire ça.
Traditionally, ce que les gens font,
c'est que vous pouvez faire un RPC
où vous pré-deployez le code.
Vous référencez le code que vous voulez appeler
sur la machine, mais vous devez s'agir
sur ce que le code va être avant-hé.
Il y a des messages passés,
mais vous devez créer un protocole.
Vous devez, je ne sais pas,
faire Jason Parsers,
Protobufs, Finagle,
etc. Vous devez faire tout ça.
Et c'est un peu un peu brit,
parce que le versionnement de ces choses
et la compétition de la back-end,
c'est que tout ça
doit être appellé.
Si vous travaillez en type de language,
rien de ça est managé par le type.
Et puis, le troisième,
c'est les messages passés.
Mais, le format de message doit être apprécié.
Vous devez
programmer dans un moyen différent
pour que vous puissiez des messages
sur le bus.
Mais, avec unicine,
pour faire un autre compétit,
vous devez créer un hash
de la code que je veux faire.
Et vous devez le faire.
Si ça n'a pas ce hash, je vous envoie
le code que le hash représente.
Et si ça a des dépendances, je vous envoie
ce que je vais faire.
Mais, je vais finalement aller à un endroit
où on s'agresse sur ce que le code est.
Et puis, vous allez le faire.
C'est un moyen intéressant que vous avez choisi
de le résoudre.
On a eu un autre guest qui a fait un projet
qui s'appelle TRPC,
qui est ce truc élaborateur.
C'est le même truc qui s'est passé.
On a un type qui a appris tout le monde
avec unicine.
C'est beau que c'est comme, oh, je faisais
ça localement, mais maintenant je veux en remontant.
Et vous dites en remontant.
Parce que la dédressabilité de contenu et le système
du tout, c'est super simple.
C'est juste un call de fonction.
C'est vrai.
La capacité de remonter ou distribuer
un truc, c'est toujours comme un call de fonction.
C'est juste un library unicine
que vous appelez et
construit un...
C'est un contenu
qui utilise des contenus
mais il y a un interpreter pour ça
qui se termine et se termine
sur un système distributaire.
Ou pas, c'est comme, vous pouvez le faire localement
Si quelqu'un est familier avec
l'Eurlang ou l'écosystème l'OTP,
comment peut-il
comparer avec quelque chose comme ça?
Ou vous? Je pense que je dois dire
avant que je vous demande.
Vous avez mis en place l'OTP ou
l'aie-tu par la question?
Je n'ai pas.
Je suis vaguely familier avec l'Eurlang.
Mais l'Eurlang a beaucoup de capacités
où vous pouvez
mettre en place l'OTP
et vous pouvez dire à un autre node
quel code vous voulez faire.
C'est très cool.
Mais
unicine est
type, c'est la seule chose.
Donc
vous
n'avez pas
de contacter
un node
et de vous envoyer un message
pour dire que c'est le code
que je veux vous faire
mais
c'est vraiment
vous mettre le code que vous voulez
en parenthèse et vous envoyer
à un fonction.
Et c'est tout type check.
Donc
vous
vous ne
ne pouvez pas
envoyer un code qui ne fait pas type check.
Oui, l'une des choses qui se passe
dans l'élicieux écosystème
de toute façon, je vais vous en parler
en parlant de
types pour élicieux.
Et l'une des choses que ils disent
c'est que
on ne va pas
faire type des messages de l'Event
parce que c'est
l'élicieux, l'Eurlang, qui est basé
sur ces procédures qui communiquent
à l'autre.
On ne va pas vraiment faire type cette boudre.
Et
c'est
quelque chose que vous avez pour le free
à l'un de la voie.
Mais
c'est huge, c'est
extrêmement powerful.
Oui, je veux dire
que l'Eurlang est
une belle langue et j'aime
ça.
J'ai seulement utilisé un très petit.
Mais
c'est
ce petit système distribué
que l'Eurlang peut être délice.
Donc
peut-être juste pour un
plus basé d'éducation
quand
vous faites
un programme unicine,
quel est l'artifact que vous faites
?
Et puis, on va dire que vous avez
un système distribué que vous essayez de
construire.
Quels sont les artifacts que vous devez
envoyer à ces autres systèmes ?
Dans le début,
vous vous mettez un interpreter unicine
et vous configurez unicine et vous vous dites
que vous pouvez connecter
à cette autre machine.
Et puis, vous connectez.
Comment ça marche ?
Ça dépend.
Si vous êtes
juste en train de faire un code,
sur votre laptop,
l'artifact
que vous exécutez
est unicine
de code.
Donc,
on comporte
dans une forme intermédiaire
et ça fonctionne dans notre temps de tour.
Vous pouvez aussi
compter
dans une code standalone, donc vous n'avez pas
de PCM en tour,
ou autre chose.
C'est comme le modèle Java,
où vous avez un code de code
dans un file, et puis vous pouvez
commencer
la machine virtuelle et
faire le code.
Mais aussi,
dans les works, et
c'est comme de très vite,
comme j'ai vu le PR
aujourd'hui,
le pull request.

on a un backend native pour ça.
Donc, ça comporte
un code native
sur votre machine.
Et ça fait ça
dans le schéz-scheme.
Unison, on génère le schéz-scheme,
et le compiler
comporte le code native.
Et on a
un compiler en temps de tour
dans les works, donc on comporte
en temps de tour.
Mais
vous voulez déployer
un
système distributaire,
ou un cloud,
ou autre chose.
Oui, vous pouvez avoir
des notes unison que vous avez déployées
à votre
cloud interne, ou autre chose,
avec Kubernetes, ou Docker,
ou autre chose.
Vous utilisez les mêmes méthodes que vous faites aujourd'hui.
Et vous pouvez
juste relier au fait que
un des notes
est en train de contrôler unison, et vous pouvez le envoyer.
Mais ça va être un peu de travail.
Ce que nous travaillons
est unison cloud,
qui sera
notre infrastructure
où
vous allez donner un library,
et vous vous
faites un appel de fonction
à ce library, et ça va déployer
votre code à notre cloud.
Devanter ce
pattern de tout, c'est juste unison code.
C'est
unison tout le monde.
Je l'aime.
C'est un moment
d'enferment.
Oui,
ce n'est pas unison,
non,
unison est en plus
en unison, mais
le UGM est en
en unison.
Donc
avant de
faire le cloud,
j'ai vu des démons super intéressants
sur ça, je veux
se débrouiller
pour des autres bénéfices que vous avez
de la adressabilité de contenu.
Il y a
un doc dans votre documentation qui s'appelle
l'idée de la grande idée qui
tourne dans toutes les
plus bons casques de goutte.
Nous en avons parlé de la construction et la check-in de type.
Ces documents mentionnent
que la nature
de la construction et la check-in de type
est un peu cool.
Vous pouvez le faire ?
Oui, c'est un des plus cool
des choses qui s'enclencent sur les biaises,
c'est que ce n'est pas
n'importe quoi.
En tant que code base,
c'est toujours dans le state de travail.
Vous avez
gradualement et incrementement
appris.
Il n'y a pas
de processus de biais
comme ça.
Vous avez un définition,
il est compilé
et
vous pouvez avoir un test de integration
et vous pouvez le faire.
Et après ce que c'est fait,
le code
fonctionne.
Il n'y a pas de
compilé et de
compilé pour que tout soit en place.
Pourquoi
les langues de programmation
généralement ont des biaises ?
La raison pour laquelle
le code,
le producte,
il faut savoir
où s'adresser
d'autres codes.
Vous devez
compiler
les biaises syntaxes
et la forme finale.
Vous devez faire sure que les
addresses de où le code est
placé dans les places correctes
pour que quand quelque chose
fait un call, il arrive
à la place correcte.
Mais,
depuis que
unisson est toujours
adressée par hash,
tous les codes,
chaque fonction,
ont un déterminisme
unibidisé global
pour qu'il n'y ait pas de
link ou de build.
Je pense que l'une des plus
basé des choses,
les compilés ne savent pas
quel code vous avez changé.
Ils peuvent avoir
des plugins,
un file a changé, je dois
récompiler un file.
Mais généralement,
vous devez avoir des systèmes
de cesse, mais ça doit
processer cet entire file
pour savoir que tout est arrivé.
Vous devez dire, je vais
ajouter une méthode,
ou changer une méthode,
ou renomber, etc.
C'est tout ça.
C'est intéressant.
Oui, mais pas de
prendre des gens
qui ont fait un cool travail
en regardant
l'incrémentale compilation
et
des idées,
les idées principales
qui ont des compilés
qui sont incrémentaux
et qui peuvent détecter
les choses que vous avez changées.
Je ne veux pas de prendre des gens.
Mais,
à l'endemain,
les shops ont un
plus grand intégration,
et vous faites surement
que tout fonctionne.
C'est un autre truc.
Avec le programme purement
fonctionnel,
si vous avez fait un test,
et que ça passait,
vous n'avez pas de faire le test
sur ce code.
C'est une faible vente de temps
pour faire le test.
Ce que la UCM fait,
c'est que ça cache les résultats de tests
et que ça ne va qu'à
faire le test
si le code
dépend de ça,
si le test
change.
C'est un concept super cool
qui
construit des tests
pour vos fonctions.
Ils ne doivent pas seulement être faits de temps
mais aussi de temps
et de compétition.
C'est probablement immense.
Et probablement un autre des effets
de ça, c'est que
si votre base code s'étend plus grand,
vous ne vous sentez pas grand.
Si j'ai un code type script
qui est de 40 000 lines,
je vais me sentir les 40 000 lines
pendant que je travaille.
Mais, unison,
tout le travail est fait
quand vous allez en train.
Comme vous l'avez dit,
votre base code est constamment
dans cette forme perfecte
et cette forme est
type checking, building, test,
tout est fait.
C'est une pensée d'après-midi.
C'est incrémentaire.
Vous vous êtes en train de travailler
dans des petites fiefdoms
de votre...
Si vous avez un grand library,
vous vous êtes en train de travailler
dans un espace de nom.
Et ça se sent très isolé
de tout le reste
de votre projet.
Vous avez joué
avec des
tools de visualisation.
C'est comme si, selon le code,
la unité est en format de data.
Je ne sais pas, un détail de
un certain...
fonctionnement,
c'est comme si c'était un truc
très trivial.
Je suis juste inquiétant.
C'est cool.
Comment est accessible
la structure d'un data
pour comment le code est en train de s'en sortir?
C'est
SQLite.
Je dirais très accessible.
Vous pouvez en faire SQL.
C'est super accessible.
Vous pouvez aller
en faire un petit tour
d'une quantité de database
et de la graphite de dépendance.
Unisson,
au moment,
le U.C.M. a des commandes
pour demander des dépendances.
Il vous donnera un liste
de les dépendances
de la chose
ou des dépendances.
Je pense que
ça vous donnera des dépendances transitive.
Je ne sais pas si vous pouvez le faire.
Est-ce que c'est un métier?
C'est un excellent question.
Oh, je veux vraiment ça.
Non, nous n'avons pas
ça à l'heure.
Mais c'est en train de faire le travail.
Unisson a un système
d'oblits
qui est un système d'effect.
Une des habilités
est IO,
non-déterminisme
et d'exceptions.
Une des habilités
que je veux vraiment
est
une habilité de code.
Vous devez dire
quels sont
les
nombres pour ce nom
ou
les définitions dans ce nom.
On va
prendre les définitions dans ce nom
et les changer.
Il y a un peu de
la base de code programmable.
Ce n'est pas un métier
qui ne génère pas de code,
mais qui parle
de base
programmable.
On a parlé
dans le podcast
et j'ai passé beaucoup de temps
en enregistrant des codes.
On peut
faire des scripts de temps,
de la code de parser
et de transformer le ST.
C'est un
union.
Encore un exemple,
c'est génial de
avoir une représentation
d'une code union
pour que vous puissiez
manipuler
le ST
avec union.
C'est un peu mal.
Vous avez mentionné les habilités
et
j'ai ré-hylite
que
les types d'algebra
sont
quelque chose
que beaucoup de languages
qui ne sont pas de la language
fonctionnelle
sont des expériences
de la vie limitée.
Les uns sont très écrits,
mais les autres sont très intéressants.
Vous avez mentionné que
les exceptions
sont représentées
comme une habilité.
C'est un point cool
et c'est difficile de
écrire.
Quand vous faites des codes
d'algebra
ou d'algebra,
les exceptions sont des extra-vectors
d'une méthode
qui a un autre comportement
qui fait quelque chose d'autre.
C'est un autre état
d'une autre state.
C'est toujours là.
Vous ne savez pas si ça peut
ou pas.
Mais si vous avez
une habilité, c'est
une définition de type
et un mécanisme
très fort.
C'est intéressant.
Les habilités
sont toutes les exceptions.
Par exemple,
l'élection de l'élection de l'IO.
Ce qui fait
que c'est une exception
pour la runtime.
Le runtime dit que c'est ça.
Vous voulez que vous printez une ligne.
Je vais faire ça.
Et puis, le contrôle de la transverse
pour votre programme.
C'est la continuation de la limite.
C'est la exception.
Part de l'élection, c'est
là où je suis dans le programme.
C'est un point de retour
pour le programme.
La continuation de la runtime
et le programme.
Qu'est-ce que
l'acier de la code?
Je pense que le stuff
est largement
lié à l'obligation.
Si vous faites un request de la chaine,
vous allez avoir l'obligation
de faire ça.
Mais, c'est
les habilités de la code
de la synchronisation?
Oui.
La code multithrédique
est liée à l'obligation de l'IO.
Il y a
une fonction de code IO.Fork.
Vous vous donnez
un code
de la synchronisation.
Vous vous donnez
une fonction
qui n'a pas d'arguments.
Vous vous donnez une de ces fonctions
qui n'a pas d'arguments.
Vous vous passerez à l'IO.Fork.
Il y a un nouveau thread
de la synchronisation.
Nous
avons des variables
que vous pouvez utiliser pour communiquer
entre
les threads.
Nous avons
une memoire transactuelle
pour utiliser
des opérations

sur les variables mutables
et les quilles mutables
et les arrays mutables.
Pour communiquer entre les threads.
Donc,
en bas de la ligne
des choses qui sont en train
de statement la congé
pour faire
sukcesse et aux
WAILK.
lain
C'est le défi, c'est ce que vous voulez.
Vous pouvez représenter votre code base à quel point de temps,
parce que c'est très facile de poursuivre les dépendances
à quel point de temps et de ce code.
Comment cette adressabilité de contenu
rend des conflits de dépendance moins de problème ?
Le fait que ça soit, c'est que les dépendances
sont représentées à un niveau de fin de graine.
C'est à l'aise de l'individu des haches.
Donc, votre code dépend de l'aise,
comme les haches que ça utilise.
Et, en tant que ces haches sont présentes dans votre code base,
comme si votre code ne compilierait pas, si ça n'était pas.
Mais, vous pouvez appeler ces haches.
Et, c'est pas le cas que vous pensez que
vous avez une version 1 de l'alibi et une version 2 de l'alibi
qui sont des dépendances transitive,
ou des autres,
je dépend de l'alibi A et de l'alibi B.
Et, ils sont tous dépendus de l'alibi C,
mais ils sont dépendus de différentes versions de l'alibi C.
Donc, ça devient un problème dans beaucoup de systèmes de compétence.
Mais, en unicine, ce n'est pas un problème,
parce que ces fonctionnes que vous utilisez
de ces libraires, que vos dépendances sont utilisées
dans ces libraires, elles peuvent juste avoir différentes haches.
Et, ils peuvent juste vivre,
rapidement, dans votre code base,
ils vont juste avoir différents names.
Et, si un type change entre une version de l'alibi et d'autres,
vous ne pourrez jamais pouvoir passer un autre,
un fonction qui attend une version avec une autre version.
Vous allez juste avoir un type ordinaire, si ça se passe.
Ça veut dire que c'est plus facile
de déployer des bas-endances
qui ont plusieurs versions et qui sont là pour toujours.
Parce que, dans un monde où je suis appelé
unicine code sur le front-end,
ma app front-end peut tout en en parler
et il n'y a pas de problème,
et le v2 s'occupe et il n'y a pas de problème,
parce que c'est juste là tout le temps.
Si votre app front-end et votre back-end sont unicines,
et vous utilisez le protocole unicine internaute
pour parler avec eux,
le front-end peut juste dire le back-end,
comme, c'est le code que je veux appeler.
C'est comme, ici est la hache, je veux appeler cette fonction,
et si le back-end n'a pas,
ils disent, oh, donnez-moi le code,
et puis, donnez-le le code,
et la hache se dit, ok, c'est bien, on va le faire.
Vous pouvez mettre votre front-end en unicine?
C'est un truc?
Oui, vous pouvez mettre
les applications console en unicine.
Il n'y a pas de library de goût,
comme d'habitude, pour mettre un end de goût.
Nous ne compilons pas le JavaScript,
comme d'habitude, et donc, nous ne pouvons pas le faire,
maintenant.
Mais, vous savez, nous pouvons voir si il y a un schéma,
compiler, de JavaScript, et si c'est le cas,
nous sommes en train de faire le browser,
dès que ça se passe.
Vous pouvez imaginer un futur où vous vous réveillez
votre front-end web et votre back-end
dans la même langue, même dans le même file,
et puis, vous savez,
ils peuvent juste parler avec eux,
avec un call de fonction,
comme si ils se sont réveillés sur la même machine.
C'est le rêve.
Il y a beaucoup de différents outils,
et beaucoup de configuration.
Ce serait juste incroyable pour ça à arriver.
Il y a beaucoup de outils,
beaucoup de configuration.
C'est tout pour cette semaine.
D'accord, le tout est disponible pour nos membres de Patreon.
Merci d'avoir regardé.