Quel est l'état actuel Fonctionnel Réactif de Programmation implémentations?
J'essaye de visualiser en quelques simples automatique de systèmes physiques (telles choses comme le pendule, les bras de robot,etc.) en Haskell.
Souvent, ces systèmes peuvent être décrits par des équations comme
df/dt = c*f(t) + u(t)
où u(t) représente une sorte de "contrôle intelligent'. Ces systèmes de chercher à s'intègrent très bien dans le Fonctionnel Réactif paradigme de Programmation.
J'ai donc pris le livre "Le Haskell École de l'Expression" par Paul Hudak,
et de constater que le langage spécifique au domaine "FAL" (pour l'Animation Fonctionnelle de la Langue) a présenté, il fonctionne très agréablement pour mon simple jouet systèmes (bien que certaines fonctions, notamment integrate, semblait être un peu trop paresseux pour une utilisation efficace, mais facilement réparable).
Ma question est, quelle est la plus mature, up-to-date, bien entretenu, des performances optimisées alternative pour les plus avancés, ou même des applications pratiques aujourd'hui?
Cette page du wiki listes de plusieurs options pour Haskell, mais je ne suis pas clair sur les points suivants:
-
Le statut de "réactif", le projet de Conal Eliott qui est (comme je le comprends), l'un des inventers de ce paradigme de programmation, ressemble un peu rassis. J'adore son code, mais je devrais peut-être essayer d'autres plus up-to-date de solutions de rechange? Quelle est la principale différence entre eux, en termes de syntaxe/performance/exécution-stabilité?
-
Pour citer un enquête en 2011, la Section 6, "... PRF implémentations ne sont pas encore assez efficaces ou assez prévisible dans la performance pour être utilisé efficacement dans des domaines qui exigent des garanties de latence ...". Alghough l'enquête suggère d'intéressantes optimisations possibles, compte tenu du fait que le FRP est là depuis plus de 15 ans, j'ai l'impression que ce problème de performances peut être quelque chose de très ou même intrinsèquement difficile à résoudre, au moins dans un délai de quelques années. Est-ce vrai?
-
Le même auteur de l'enquête parle de "temps fuites" dans son blog. Le problème est unique à la fibre de verre, ou quelque chose que nous sommes généralement lors de la programmation pure, non-stricte de la langue? Avez-vous déjà trouvé tout simplement trop difficile à stabiliser une PRF-fondé du système au fil du temps, si pas assez performant?
-
Est-ce encore un niveau de recherche du projet? Sont les gens comme ingénieurs d'usine, la robotique, les ingénieurs, les ingénieurs financiers, etc. leur utilisation (dans whaterver de la langue qui convient le mieux à leurs besoins)?
Bien que personnellement, je préfère un Haskell mise en œuvre, je suis ouvert à d'autres suggestions. Par exemple, il serait particulièrement amusant d'avoir un Erlang mise en œuvre --- il serait alors très facile d'avoir un d'intelligent, d'adaptation, d'auto-apprentissage, processus de serveur!
Vous devez vous connecter pour publier un commentaire.
Actuellement, il existe principalement deux types de pratiques Haskell bibliothèques fonctionnel réactif de programmation. Les deux sont maintenus par des personnes seules, mais reçoivent des contributions de code à partir d'autres Haskell programmeurs ainsi:
Netwire met l'accent sur l'efficacité, la flexibilité et la prévisibilité. Il a son propre événement de paradigme et peut être utilisé dans les zones où les PRF ne fonctionne pas, y compris les services de réseau et des simulations complexes. Style: applicative et/ou arrowized. Auteur et mainteneur: Ertugrul Söylemez (c'est moi).
réactif-banane s'appuie sur le traditionnel PRF paradigme. Alors qu'il est pratique à utiliser, il sert également de terrain classique de PRF de recherche. Son accent est mis sur les interfaces utilisateur et il est un ready-made de l'interface de wx. Style: applicative. Auteur et mainteneur: Heinrich Apfelmus.
Vous devriez essayer les deux d'entre eux, mais en fonction de votre demande, vous trouverez probablement un ou l'autre, être un meilleur ajustement.
Pour les jeux, la mise en réseau, le contrôle d'un robot et des simulations, vous trouverez Netwire pour être utile. Il est livré avec ready-made fils pour les applications, y compris les diverses utile différentielles, intégrales et beaucoup de fonctionnalités pour la transparence de la gestion des événements. Pour un tutoriel visite de la documentation de l'
Control.Wiremodule sur la page.Pour les interfaces utilisateur graphiques actuellement, le meilleur choix est le réactif-banane. Il a déjà une wx interface (comme une bibliothèque séparée réactif-banane-wx) et Heinrich blogs beaucoup sur PRF dans ce contexte, y compris des exemples de code.
Pour répondre à vos autres questions: FRP n'est pas approprié dans le cas où vous avez besoin en temps réel de la prévisibilité. Ceci est largement dû à Haskell, mais malheureusement, le FRP est difficile à réaliser dans des langages. Dès que Haskell devient elle-même en temps réel-prêt, PRF va y arriver, trop. Sur le plan conceptuel Netwire est prêt pour les applications en temps réel.
Temps les fuites ne sont pas vraiment plus un problème, car ils sont en grande partie liées à la monadique cadre. Pratique PRF implémentations n'ont tout simplement pas offrir un monadique de l'interface. Yampa a commencé ce et Netwire et réactif-banane à la fois construire que sur la.
Je ne connais pas de commerciaux ou autres projets à grande échelle à l'aide de PRF droit maintenant. Les bibliothèques sont prêtes, mais je pense que les gens ne sont pas – encore.
Bien qu'il existe quelques bonnes réponses déjà, je vais tenter de répondre à vos questions spécifiques.
réactif n'est pas utilisable pour des projets sérieux, à cause des problèmes de fuite. (voir #3). La bibliothèque actuelle avec le plus de modèle similaire est réactif-la banane, qui a été développé avec le réactif comme une source d'inspiration, et en discussion avec Conal Elliott.
Bien que Haskell lui-même est inapproprié pour dur des applications en temps réel, il est possible d'utiliser Haskell doux pour des applications temps-réel dans certains cas. Je ne suis pas familier avec la recherche actuelle, mais je ne pense pas que ce soit un problème insurmontable. Je soupçonne que ce soit comme les systèmes de Yampa, ou la génération de code tels que les systèmes de l'Atome, sont peut-être la meilleure approche pour résoudre ce.
Une "fuite" est un problème spécifique à commutable PRF. La fuite se produit quand un système est incapable de gratuit vieux objets, car il peut en avoir besoin si un commutateur devaient se produire à un certain point dans l'avenir. En plus d'une fuite de mémoire (ce qui peut être très grave), une autre conséquence est que, lorsque l'interrupteur se produit, le système doit faire une pause alors que la chaîne de vieux objets traversée pour générer de l'état actuel.
Non-commutables prf bibliothèques comme Yampa et les anciennes versions de réactif-banane ne souffrent pas de temps de fuites. Commutable prf bibliothèques utilisent généralement l'une des deux formules: soit ils ont une spéciale "création monade", dans lequel PRF valeurs sont créés ou qu'ils utilisent un "vieillissement" type de paramètre pour limiter les contextes dans lesquels les commutateurs peuvent se produire. elerea (et éventuellement netwire?) l'utilisation de l'ancienne, alors que réactif de banane et de pamplemousse utiliser celui-ci.
Par "commutable prf", je veux dire celui qui met en œuvre Conal de la fonction
switcher :: Behavior a -> Event (Behavior a) -> Behavior a, ou sémantique identique. Cela signifie que la forme du réseau dynamique peut être l'interrupteur que c'est exécuter.Ce n'est pas vraiment en contradiction avec @ertes à propos de monadique interfaces: il s'avère que la prestation d'un
Monadexemple pour unEventprend le temps de fuites possible, et avec l'une des méthodes ci-dessus, il n'est plus possible de définir l'équivalent Monade instances.Enfin, bien qu'il y a encore beaucoup de travail reste à faire avec de la fibre de verre, je pense que certaines des nouvelles plateformes (réactif-banane, elerea, netwire) sont stables et suffisamment matures pour que vous pouvez construire fiable de code. Mais vous pouvez avoir besoin de passer beaucoup de temps à apprendre les tenants et les aboutissants afin de comprendre comment obtenir de bonnes performances.
Je vais à la liste d'un couple d'éléments dans le Mono et .Net espace et une de Haskell espace que j'ai trouvé pas trop longtemps. Je vais commencer avec Haskell.
De l'orme - lien
Sa description de son site:
Il a sa propre variante de PRF. De jouer avec ses exemples, il semble assez mature.
Réactif Extensions - lien
Description à partir de sa page d'accueil:
Réactif Extensions vient de MSFT et met en œuvre de nombreux excellents opérateurs de simplifier la gestion des événements. Il a été open source juste un il ya quelques jours. Il est très mature et utilisé dans la production; à mon avis, il aurait été plus agréable de l'API pour Windows 8 Api que le TPL-bibliothèque fournit; car observables peut être à la fois le chaud et le froid et de tentative d'appel/fusionné etc, alors que les tâches représentent toujours à chaud ou à faire des calculs qui sont soit en cours d'exécution, défectueuses ou de les compléter.
J'ai écrit le code côté serveur à l'aide de Rx pour asynchronocity, mais je dois avouer que l'écriture fonctionnellement en C# peut être un peu gênant. F# a un couple de papiers, mais il a été difficile de suivre les API de développement, parce que le groupe est relativement fermé et n'est pas promu par MSFT à l'instar d'autres projets.
De son open sourcing est venu avec l'open sourcing de ses IL-de-JS compilateur, de sorte qu'il pourrait probablement travailler bien avec du JavaScript ou de l'Orme.
Vous pourriez probablement lier F#/C#/JS/Haskell ensemble très bien à l'aide d'un message broker, comme RabbitMQ et SocksJS.
Bling UI Toolkit - lien
Description à partir de sa page d'accueil:
Gratuit LtU-article.
J'ai testé, mais pas travaillé avec elle pour un projet client. C'est génial, a nice C# surcharge d'opérateur qui forment les liaisons entre les valeurs. Il utilise les propriétés de dépendance dans WPF/SL/(WinRT) comme sources d'événements. Ses animations 3D, fonctionnent bien raisonnable de matériel. Je voudrais utiliser ce si je me retrouve sur un projet dans le besoin pour des visualisations; probablement le portage vers Windows 8.
ReactiveUI - lien
Paul Betts, à MSFT, maintenant sur Github, a écrit ce cadre. J'ai travaillé avec elle assez largement et comme le modèle. C'est plus découplée de Clignoter (de par sa nature, à partir de l'aide de Rx et de ses abstractions), il facilite l'unité de test de code de l'utiliser. Le github git client pour Windows qui est écrit dans ce.
Commentaires
Le modèle réactif est assez performant pour un maximum de performances des applications exigeantes. Si vous envisagez de dur en temps réel, j'avais parier que la plupart GC-langues ont des problèmes. Rx, ReactiveUI créer une certaine quantité de petits objets qui doivent être GCed, parce que c'est la façon dont les abonnements sont créés/cédées et les valeurs intermédiaires sont poursuivis dans le réactif de "monade" de rappels. En général, sur .Net je préfère réactif de programmation au cours de la tâche de programmation, car les rappels sont statiques (connue au moment de la compilation, aucune allocation), tandis que les tâches sont allouées dynamiquement (pas connu, tous les appels besoin d'un exemple, les déchets créés) - lambdas et de compiler dans générées par le compilateur classes.
Évidemment C# et F# sont strictement évaluées, en temps de fuite n'est pas un problème ici. Même pour les JS. Il peut être un problème avec rejouables ou mis en cache observables si.
u(t)et les simulations pourf(t). Est-ce le cas pour F# implémentations?