С++ Application Plugins

In this post I will describe an example of adding functionality to a C ++ application using plugins. The practical part of the implementation for Linux is described; the theory can be found at the links at the end of the article.

Composition over inheritance!

To begin with, we will write a plugin – a function that we will call:

#include "iostream"

using namespace std;

extern "C" void extensionEntryPoint() {
	cout << "Extension entry point called" << endl;
};

Next, we will build the plugin as a dynamic library “extension.so”, which we will connect in the future:
clang++ -shared -fPIC extension.cpp -o extension.so

Next we write the main application that will load the file “extension.so”, look for a pointer to the function “extensionEntryPoint” there, and call it, typing errors if necessary:

#include "iostream"
#include "dlfcn.h"

using namespace std;

typedef void (*VoidFunctionPointer)();	

int main (int argc, char *argv[]) {

	cout << "C++ Plugins Example" << endl;

	auto extensionHandle = dlopen("./extension.so", RTLD_LAZY);
	if (!extensionHandle) {
		string errorString = dlerror();
		throw runtime_error(errorString);
	}

	auto functionPointer = VoidFunctionPointer();
	functionPointer = (VoidFunctionPointer) dlsym(extensionHandle, "extensionEntryPoint");
	auto dlsymError = dlerror();
 	if (dlsymError) {
		string errorString = dlerror();
		throw runtime_error(errorString);
 	}

	functionPointer();

	exit(0);
} 

The dlopen function returns a handler for working with a dynamic library; dlsym function returns a pointer to the required function by string; dlerror contains a pointer to the string with the error text, if any.

Next, build the main application, copy the file of the dynamic library in the folder with it and run. The output should be the “Extension entry point called”

Difficult moments include the lack of a single standard for working with dynamic libraries, because of this there is a need to export the function to a relatively global scope with extern C; the difference in working with different operating systems associated with this subtlety of work; the lack of a C ++ interface to implement OOP approach to working with dynamic libraries, however, there are open-source wrappers, for example m-renaud/libdlibxx

Example Source Code

https://gitlab.com/demensdeum/cpppluginsexample

Documents

http://man7.org/linux/man-pages/man3/dlopen.3.htm
https://gist.github.com/tailriver/30bf0c943325330b7b6a
https://stackoverflow.com/questions/840501/how-do-function-pointers-in-c-work

Flutter comme Michelle

[Ressentez la puissance de l’intelligence artificielle]
Dans cet article, je vais vous expliquer comment prédire l’avenir.

Dans les statistiques, il existe une classe de problèmes : analyse de séries chronologiques. Ayant une date et la valeur d’une certaine variable, vous pouvez prédire la valeur de cette variable dans le futur.
Au début, je voulais implémenter une solution à ce problème en utilisant TensorFlow, mais j’ai trouvé la bibliothèque Prophète par Facebook.
Prophet vous permet de faire une prévision basée sur des données (csv) contenant des colonnes de date (ds) et de valeur variable (y). Vous pouvez découvrir comment l’utiliser dans la documentation du site officiel dans la section Démarrage rapide
En tant qu’ensemble de données, j’ai utilisé un téléchargement CSV depuis le site https://www.investing.com, lors de l’implémentation, j’ai utilisé Langage R et API Prophète pour lui. J’ai beaucoup aimé R, car sa syntaxe simplifie le travail avec de grandes quantités de données, permet d’écrire plus simplement et de faire moins d’erreurs qu’en travaillant avec des langages conventionnels (Python), puisqu’il faudrait travailler avec des expressions lambda, et dans R vous avez déjà toutes les expressions lambda .
Afin de ne pas préparer les données pour le traitement, j’ai utilisé le package anytime, qui peut convertir des chaînes en date, sans prétraitement. La conversion des chaînes monétaires en nombres s’effectue à l’aide du package readr .

En conséquence, j’ai reçu une prévision selon laquelle Bitcoin coûtera 8 400 $ d’ici la fin de 2019 et le taux de change du dollar sera de 61 roubles. Faut-il croire ces prévisions ? Personnellement, je pense que ça n’en vaut pas la peine, parce que… Vous ne pouvez pas utiliser de méthodes mathématiques sans en comprendre l’essence.

Sources

https:// facebook.github.io/prophet
https://habr.com/company/ods/blog/323730/
https://www.r-project.org/

Code source

https://gitlab.com/demensdeum/MachineLearning/tree/master/4prophet

Tesla parle

Dans cet article, je décrirai le processus de création d’un générateur de devis.

TL;DR

Pour la formation et la génération de texte &#8211 ; utilisez la bibliothèque textgenrnn, pour filtrer les phrases, vous devez utiliser la vérification orthographique à l’aide du hunspell et ses bibliothèques pour C/python. Après une formation à Colaboratory, vous pouvez commencer à générer du texte. Environ 90 % du texte sera complètement illisible, cependant, les 10 % restants contiendront un peu de sens, et avec une modification manuelle, les phrases auront l’air plutôt bien.
Le moyen le plus simple est de lancer un réseau neuronal prêt à l’emploi dans Colaboratory :
https://colab.research.google.com/drive/1-wbZMmxvsm3SoclJv11villo9VbUesbc(s’ouvre dans un nouvel onglet)”>https://colab.research.google.com/drive/1-wbZMmxvsm3SoclJv11villo9VbUesbc

Code source

https://gitlab.com/demensdeum/MachineLearning/tree/master/3quotesGenerator

Sources

https://karpathy.github.io/2015/05/21/rnn-effectiveness/https://medium.com/deep-learning-turkey/google-colab-free-gpu-tutorial-e113627b9f5dhttps://minimaxir.com/2018/05/text-neural-networks/
https://github.com/wooorm/dictionaries (opens in a new tab)” href=”https://minimaxir.com/2018/05/text-neural-networks/” target=”_blank”>https://minimaxir.com/2018/05/text-neural-networks/
https://karpathy.github.io/2015/05/21/rnn-effectiveness/
https://medium.com/deep-learning-turkey/google-colab-free-gpu-tutorial-e113627b9f5d
https://karpathy.github.io/2015/05/21/rnn-effectiveness/ (opens in a new tab)” href=”https://karpathy.github.io/2015/05/21/rnn-effectiveness/” target=”_blank”>https://karpathy.github.io/2015/05/21/rnn-effectiveness/
https://medium.com/deep-learning-turkey/google-colab-free-gpu-tutorial-e113627b9f5d
https://karpathy.github.io/2015/05/21/rnn-effectiveness/https://medium.com/deep-learning-turkey/google-colab-free-gpu-tutorial-e113627b9f5dhttps://github.com/wooorm/dictionaries

” rel=”noopener” target=”_blank”>https://github.com/wooorm/dictionaries (opens in a new tab)”>https://github.com/wooorm/dictionaries

Combien d’erreurs as-tu là ?

Sur Hacker News, j’ai trouvé un article très intéressant dans lequel l’auteur suggère d’utiliser le Méthode Petersen-Lincoln, utilisée par les biologistes pour compter la population d’oiseaux, de singes et d’autres animaux, pour *roulement de tambour* compter les bugs dans l’application.

Insecte dans son habitat naturel &#8211 ; Observation de Bigfoot par Derek Hatfield

La méthode est très simple, on en prend deux ornithologues, ils trouvent les oiseaux d’une certaine espèce, leur tâche – déterminer la taille de la population de ces oiseaux. Les oiseaux trouvés sont marqués par les deux ornithologues, puis le nombre d’oiseaux communs est calculé, substitué dans la formule de l’indice de Lincoln et nous obtenons la taille approximative de la population.
Passons maintenant aux applications – la méthode est aussi très simple, on prend deux QA et ils trouvent des bugs dans l’application. Disons qu’un testeur a trouvé 10 bugs (E1) et que le deuxième testeur a trouvé 20 bugs (E2), maintenant nous prenons le nombre total de bugs – 3 (S), puis en utilisant la formule on obtient l’indice de Lincoln :

Il s’agit d’une prévision du nombre de bugs dans l’ensemble de l’application, dans l’exemple donné, il y a environ 66 bugs.

Exemple rapide

J’ai mis en place un banc de test pour tester la méthode, vous pouvez le voir ici :
https://paiza.io/projects/AY_9T3oaN9a-xICAx_H4qw?language=swift

Paramètres modifiables :

laissez aliceErrorFindProbability = 20 – pourcentage de bugs trouvés par QA Alice (20%)
laissez bobErrorFindProbability = 60 – pourcentage de bugs trouvés par QA Bob (60%)
soit actualBugsCount = 200 – combien de bugs y a-t-il réellement dans l’application

Lors de la dernière exécution, j’ai reçu les données suivantes :
Nombre de bugs d’estimation : 213
Nombre réel de bugs : 200

C’est-à-dire qu’il y a 200 bugs dans l’application, le Lincoln Index donne une prévision – 213 :
“Alice a trouvé 36 bugs”
“Bob a trouvé 89 bugs”
“Nombre de bogues courants : 15”

Nombre de bugs d’estimation : 213
Nombre réel de bugs : 200

Faiblesses

Cette méthode peut être utilisée pour évaluer le nombre d’erreurs dans l’application à toutes les étapes de développement ; idéalement, le nombre de bugs devrait diminuer. Les faiblesses de la méthode incluent le facteur humain, puisque le nombre de bugs trouvés par deux testeurs devrait être différent et que des bugs différents ont été trouvés, cependant il faut trouver les plus courants, sinon la méthode ne fonctionnera pas (zéro bug commun – division par zéro)< br />De plus, un concept tel que les bugs courants nécessite la présence d’un expert pour comprendre leurs points communs.

Sources

Combien d’erreurs reste-t-il à trouver ? – John D. Cook, PhD, président
The thrill of the chase – Brian Hayes

Code source

https://paiza.io/projects/AY_9T3oaN9a-xICAx_H4qw ?langue=rapide
https://gitlab.com/demensdeum/statistics/tree/master/1_BugsCountEstimation/src

Engrenages de meulage

Oh muse, comme il est parfois difficile de t’attraper.
Le développement de Death-Mask et des frameworks associés (Flame Steel Core, Game Toolkit, etc.) est suspendu pendant plusieurs mois afin de décider de la partie artistique du jeu, de la musique, du son et du gameplay.
Plans – créer un éditeur pour le Flame Steel Game Toolkit, écrire un interpréteur pour les scripts de jeu (basé sur la syntaxe Rise), implémenter le jeu Death-Mask pour autant de plateformes que possible.
L’étape la plus difficile a été franchie – en pratique, la possibilité d’écrire votre propre moteur de jeu multiplateforme, votre propre IDE et un ensemble de bibliothèques a été prouvée.
Je passe à l’étape de création d’un projet vraiment réfléchi et intéressant, restez à l’écoute.

Robot d’exploration d’actualités pour iOS

Explorateur d’actualités iOS – l’application recherche du texte et affiche le résultat lors du chargement.
La prise en charge des fichiers volumineux est incluse dès le départ (> 200 Mo), les résultats sont enregistrés dans le fichier result.log.
Conception simple et réfléchie.
Prise en charge des expressions régulières à l’aide de la bibliothèque Regex.

Code source :
https://gitlab.com/demensdeum/news-crawler

Masque mortuaire dans le domaine public

À partir d’aujourd’hui, le jeu Death-Mask entre en accès libre – ; Vous pouvez suivre l’avancement de la mise en œuvre du jeu sur le lien : (Wow !)
[Masque de la mort sauvage]

Version actuelle – La version 0.1 contient les commandes fléchées de base, wsad, la génération de cartes, les objets (y compris le masque mortuaire !), le rendu.
Il y a encore beaucoup de travail à faire et je suis très intéressé par vos retours – vous pouvez donc écrire des commentaires sur la page avec la version sauvage du jeu.
Dans la version finale, le jeu se termine une fois que le joueur a trouvé l’objet « ; Masque mortuaire
Bon test : )

Авторы ресурсов

Utilitaire d’indexation du code source Hangar18

Hangar18 – Utilitaire d’indexation de code source C++ écrit en Rust. Cet utilitaire implémentera la fonctionnalité « aller à la définition » ; dans l’IDE Sabre-Plus.
L’entrée de l’utilitaire est le chemin absolu vers le répertoire du code source et la ligne de déclaration qui doit être trouvée. La sortie est de type grep.

Code source :
https://gitlab.com/demensdeum/hangar18

Taytay surveille l’état des référentiels Git

Je présente à votre attention Taytay – un utilitaire pour surveiller l’état des référentiels git pour le langage Swift. Actuellement, Swift peut être installé sur tous les systèmes d’exploitation de bureau courants. Pour Ubuntu, je recommande d’utiliser Swiftenv. Lié Taytay à l’utilitaire git-cola, mais vous pouvez modifier la source et la remplacer par n’importe quel autre programme.

Code source :
https://gitlab.com/demensdeum/taytay

Nous avons battu Malevich, carrés noirs OpenGL

Malevich arrive périodiquement à tout développeur sur OpenGL. Cela se produit de façon inattendue et hardiment, vous commencez simplement le projet et voyez un carré noir au lieu d’un merveilleux rendu:

Aujourd’hui, je décrirai la raison pour laquelle j’ai été visité par un carré noir, les problèmes trouvés à cause de quel OpenGL ne dessine rien à l’écran, et rend parfois même la fenêtre transparente.

Utilisez des outils

Pour le débogage OpenGL, deux outils m’ont aidé: renderdoc et et . RenderDoc & # 8211; Outil pour déboguer le processus de rendu OpenGL, vous pouvez tout voir & # 8211; Vertexes, shaders, textures, messages de la dette du pilote. Apitrace & # 8211; Un outil pour relever les défis d’une API graphique, fait des appels à vidage et affiche des arguments. Il y a aussi une excellente occasion de comparer deux décharges via Wdiff (ou sans, mais pas si pratique)

Vérifiez avec qui vous travaillez

J’ai un système d’exploitation Ubuntu 16.10 avec les anciennes dépendances SDL2, GLM, ASSIMM, GLEW. Dans la dernière version d’Ubuntu 18.04, j’obtiens l’assemblage du jeu Death-Mask qui ne montre rien à l’écran (seulement un carré noir). Lorsque vous utilisez le chroot et l’assemblage à 16.10 I , j’obtiens un assemblage de travail du jeu avec des graphiques .

Il semble que quelque chose soit cassé dans Ubuntu 18.04

LDD a montré le linkka aux bibliothèques identiques SDL2, GL. En conduisant une construction non travaillant dans RenderDoc, j’ai vu des ordures à l’entrée du vertex shader, mais j’avais besoin d’une confirmation plus solide. Afin de comprendre la différence entre les binares, je les ai conduits à tous les deux via apitrace . La comparaison des décharges m’a montré que l’assemblée sur un nouveau Ubunta rompt le programme des prospects dans OpenGL, en réellement des ordures là-bas:

Les matrices se rassemblent dans la bibliothèque GLM. Après avoir copier GLM à partir de 16,04 & # 8211; J’ai à nouveau obtenu la construction de travail du jeu. Le problème était la différence dans l’initialisation d’une seule matrice dans GLM 9.9.0, il est nécessaire d’indiquer clairement l’argument MAT4 (1.0f) dans le constructeur. Ayant changé l’initialisation et en rangeant l’auteur de la bibliothèque, j’ai commencé à faire Teste pour FSGL . Dans le processus d’écriture que j’ai trouvé des défauts dans FSGL, je les décrirai davantage.

Déterminez qui est dans la vie

Pour le bon travail avec OpenGL, vous devez volontairement de force demander le contexte d’une certaine version. Il recherche donc SDL2 (vous devez mettre la version strictement avant d’initialiser le contexte):


 sdl_gl_seettrtribute (sdl_gl_context_major_version,  3 );
Sdl_gl_settribute (sdl_gl_context_minor_version, 2 );
Sdl_gl_settribute (sdl_gl_context_profile_mask, sdl_gl_context_profile_core);

Par exemple, RenderDoc ne fonctionne pas avec des contextes inférieurs à 3.2. Je voudrais noter qu’après changer le contexte , il y a une forte probabilité de voir le même écran noir . Pourquoi?

Parce que le contexte d’OpenGL 3.2 doit nécessiter la présence de tampon VAO , sans lesquels 99% des conducteurs graphiques ne fonctionnent pas. Ajoutez-le facile:


 glGenverTexArrays ( 1 ,  &  vao);
Glbindvertexaray (vao);

Ne dormez pas, gel

J’ai également rencontré un problème intéressant sur Kubuntu, au lieu d’un carré noir, j’ai été montré transparent, et parfois tout a été rendu correctement. J’ai trouvé la solution à ce problème à Stack Overflow:

https://stackoverflow.com/questions/38411515/sdl2-opengl-window-appears-semi-transparent-sometimes

Le code de rendu de test FSGL était également présent sommeil (2s) ; Donc, sur le Xubuntu et Ubuntu, j’ai reçu le rendu correct et envoyé la demande endormie, mais sur Kubuntu, j’ai reçu un écran transparent dans 80% du lancement de Dolphin et 30% des lancements et du terminal. Pour résoudre ce problème, j’ai ajouté le rendu dans chaque trame, après une enquête SDlevent, comme recommandé dans la documentation.

Code de test:
https://gitlab.com/demensdeum/FSGLtests/blob/master/renderModelTest/

Parlez au conducteur

OpenGL prend en charge le canal de communication entre l’application et le pilote, pour l’activer, vous devez allumer les drapeaux GL_DEBUG_OUTPUT, GL_DEBUG_OUTPUT_SYNCHRONUS, APPIX L’ARTIPE GLDEBUGMESSAGECONTROL et TIE THE CALBACK AUX CLACK CLASS = “PL-PLE-C1” .
Un exemple d’initialisation peut être pris ici:
https://github.com/rock-core/gui-vizkit3d/blob/master/src/EnableGLDebugOperation.cpp

N’aie pas peur, regarde-le grandir

Dans cet article, je parlerai de mes mésaventures avec les pointeurs intelligents shared_ptr. Après avoir implémenté la génération de niveau supérieur dans mon jeu Death-Mask, j’ai remarqué un souvenir fuir . Chaque nouveau niveau donnait une augmentation de + 1 mégaoctet à la RAM consommée. Il est évidemment que certains objets sont restés en mémoire et ne l’ont pas libéré. Pour corriger ce fait, il a fallu mettre en œuvre la bonne mise en œuvre des ressources lorsque le niveau est surchargé, ce qui n’a apparemment pas été fait. Depuis que j’ai utilisé des pointeurs intelligents, il y avait plusieurs options pour résoudre ce problème, la première impliquait une révision manuelle du code (longue et ennuyeuse), tandis que la seconde impliquait de rechercher les capacités du débogueur lldb et le code source de libstdc++ pour la possibilité de suivre automatiquement changements de compteur.

Sur Internet, tous les conseils se résumaient à réviser manuellement le code, à le corriger et à se frapper avec des fouets après avoir trouvé la ligne de code problématique. Il a également été proposé d’implémenter son propre système de travail avec la mémoire, comme le font tous les grands projets développés depuis les années 90 et 2000, avant l’arrivée des pointeurs intelligents dans le standard C++11. J’ai essayé d’utiliser des points d’arrêt sur le constructeur d’une copie de tous les shared_ptrs, mais après plusieurs jours, rien d’utile ne s’est produit. Il y avait une idée pour ajouter la journalisation à la bibliothèque libstdc++, mais les coûts de main d’œuvre se sont avérés monstrueux.


Cowboy Bebop (1998)

La solution m’est soudainement venue à l’esprit : suivre les modifications apportées à la variable privée shared_ptr – use_count. Cela peut être fait en utilisant les points de surveillance intégrés dans lldb. Après avoir créé un shared_ptr via make_shared, les modifications apportées au compteur dans lldb peuvent être suivies à l’aide de la ligne :

regarder set var camera._M_refcount._M_pi->_M_use_count

Où « caméra » ; il s’agit d’un objet shared_ptr dont l’état du compteur doit être suivi. Bien sûr, les composants internes de shared_ptr varieront en fonction de la version de libstdc++, mais le principe général peut être compris. Après avoir installé le point de surveillance, nous lançons les applications et lisons le stacktrace de chaque changement de compteur, puis nous regardons le code (sic !), trouvons le problème et le réparons. Dans mon cas, les objets n’ont pas été libérés des tables de cache et des tables de logique de jeu. J’espère que cette méthode vous aidera à gérer les fuites lorsque vous travaillez avec shared_ptr et j’aimerai encore plus cet outil de mémoire. Bon débogage.

Vision des jeux #3

Le troisième numéro d’une chronique non permanente sur les jeux Games Vision.

Observer (PC et consoles, Bloober Team) – horreur cyberpunk des vaillants Polonais. Un film d’horreur court et très atmosphérique avec Rutger Hauer. En tant que fan de cyberpunk, j’ai absolument tout aimé du jeu. Des énigmes pas très difficiles, des pépins charmants du personnage principal, un gameplay avec des moments calmes mêlés d’action, la possibilité de se plonger littéralement dans les souvenirs des morts, une intrigue de style Ghost in the Shell + de nombreuses références à la culture pop Sci-Fi. Parmi les inconvénients – trop de problèmes, il semble parfois qu’en raison de leur abondance, il est impossible de jouer, et certains joueurs étaient également enragés par des éléments d’horreur spécifiques qui étaient si effrayants qu’ils ne pouvaient pas continuer à jouer.
Note : 8/10

Paradigm (Windows/OS X, Jacob Janerka) – une quête qui parvient à parodier et à rire de tout à la fois. Il y a le ridicule de l’URSS, de l’Amérique, du genre quête, du glam rock, des vieilles consoles, des gens, des monuments, des informaticiens, des cônes, des ordinateurs, des femmes, des enfants, des parents, des artistes, de l’amour, des scientifiques, de l’industrie du jeu, des joueurs eux-mêmes et #8211 ; En général, il est impossible de tout énumérer. Intrigue absolument imprévisible, atmosphère et art absurdes, énigmes pas particulièrement difficiles. Le jeu présente de rares bugs et crashs, certains moments et blagues sont légèrement prévisibles et non originaux.
Note : 9/10

Late Shift (PC et consoles, CtrlMovie Ltd) – film interactif. Je suis vraiment désolé qu’une idée fondamentalement bonne ait été si mal mise en œuvre. Tout va mal – intrigue, manque d’acteurs vedettes, jeu d’acteurs, blocages constants dans la version PC, variabilité presque nulle (illusoire). Il est totalement incompréhensible comment il a été possible de sortir un jeu avec autant de problèmes dans les années 2010, car en fait il s’agit d’un lecteur vidéo ordinaire, le jeu entier aurait pu être publié sur Internet, par exemple sur YouTube, mais à la place ils ont utilisé Unity et a réussi à briser même un moteur de jeu aussi puissant. Le forum officiel sur Steam est dédié aux correctifs, hotfix, solutions de contournement, etc. Il y a une catastrophe technique, manque de support utilisateur, tous les tests se font directement sur les joueurs. J’ai acheté des critiques et des témoignages élogieux.
Note : 3/10

Langage de programmation Rise

Je présente à votre attention mon propre langage de programmation appelé « – Lève-toi. Un transpileur de Rise vers JavaScript est actuellement disponible.

Vous pouvez le voir et l’utiliser sur le lien ci-dessous – Rise en JavaScript (dialecte ECMAScript 5) :
https://gitlab.com/demensdeum/Rise

Je présente également à votre attention une application de démonstration entièrement écrite en Rise :

Code source de l’application de démonstration Rise :
https://gitlab.com/demensdeum/RiseDemoApplication

Vous pouvez m’écrire si vous ai-je des idées, des suggestions, des commentaires sur la nouvelle langue.

Noyau de la corruption

Il était difficile de respirer ; l’écran du casque indiquait l’apport d’oxygène pendant exactement une demi-heure. Pendant ce temps, Revil prévoyait d’atteindre le centre-ville et d’obtenir le masque mortuaire. Il y avait un brouillard vert âcre tout autour, il n’y avait pas d’air ici, des gens à moitié morts erraient dans les rues, des créatures capturées par l’influence du Masque.
Le bruit des pas se répandit dans les pièces vides du bâtiment abandonné, Revil se déplaça avec précaution, ne sachant pas à quoi s’attendre dans l’endroit le plus dangereux du Technolab.

Ne bougez pas !
par M-Delcambre

La ville a longtemps été capturée par la corruption, mais pas par la corruption terrestre, qui asservit l’esprit des politiciens et des avides de pouvoir. La corruption de Death Mask s’empare de l’esprit des êtres vivants, ils perdent le contrôle d’eux-mêmes et commencent à vivre pour réaliser ses désirs. Tous ceux qui étaient sous influence ont commencé à croire qu’ils recevraient la vie éternelle grâce à leur service. Pour garder le contrôle, le Masque nécessite un afflux constant de nouveaux esclaves et la capture de nouveaux territoires avec des créatures pures.

Au nord-ouest, Revil a vu la lueur bleue dont Alice lui a parlé ; au centre se trouve un immense bâtiment créé par les constructeurs du Technolab. Une accumulation étrange et grotesque de cadres saillants et de pièces mécaniques, comme créée par un fou, avait une apparence terrifiante.

Revil descendait de la fenêtre de l’immeuble dans la rue pour continuer son voyage, quand soudain il entendit le fort impact de membres métalliques sur l’asphalte. En se retournant, il vit le Démon devant lui… une créature biomécanique à trois têtes humaines, semblable à une araignée, se dirigeait lentement vers lui. Un cercle d’une étrange couleur noir miroir est apparu dans le ciel ; il était difficile de détourner les yeux. Il y eut un rugissement assourdissant de la sirène de la ville, appelant les créatures esclaves à aider le Démon. La situation était vraiment mauvaise, mais Revil avait préparé une surprise pour cette affaire…

Sabre-Plus C++ IDE

J’ai commencé à développer mon propre IDE pour C++ – Sabre-Plus. Les idées principales du nouvel IDE – être simple, rapide et *utile* dans le développement. Pour le moment, le code source est disponible sous licence MIT sur GitHub et est utilisé pour fonctionner avec l’interface utilisateur. À l’avenir, je prévois de transférer tous les développements liés au C++ vers Sabre-Plus – Death-Mask sera définitivement migré. Plus de détails sur les points :

  • Simple – il est prévu de ne pas en ajouter plus que nécessaire – par exemple, ne contiennent pas de clients de contrôle de source, de terminal intégré et d’éléments similaires. La fonctionnalité se concentre uniquement sur l’édition de code et l’analyse des erreurs. Le code de l’éditeur doit être décomposé en classes simples qui font leur part correctement (à la manière d’Unix)
  • Rapide – concerne à la fois la base de code de l’IDE et le comportement de l’éditeur lui-même. Toutes les actions dans l’EDI doivent être aussi rapides que possible, même les actions souvent longues et complexes comme la création/importation de projets.
  • Aider – analyse des erreurs typiques lors de l’écriture et de la compilation de code. Correction des erreurs et des avertissements à la demande de l’utilisateur. Le plan est d’ajouter une analyse de la construction de l’application sur une plate-forme spécifique et d’afficher des informations d’aide sur l’installation des bibliothèques et des composants nécessaires.

Pour créer l’éditeur pour votre système d’exploitation, vous devez installer le SDK Qt 5, télécharger le code IDE depuis le référentiel, ouvrir le fichier Saber-Plus.pro dans Qt Creator et exécuter le build :

https://github.com/demensdeum/saberplus

Exemple simple de TensorFlow

Je présente à votre attention un exemple simple de travail avec un framework pour travailler avec le Deep Learning – TensorFlow. Dans cet exemple, nous allons apprendre à un réseau de neurones à détecter les nombres positifs, négatifs et zéro. Installation de TensorFlow et CUDA Je vous informe, cette tâche n’est vraiment pas facile)

Pour résoudre les problèmes de classification, classificateurs. TensorFlow dispose de plusieurs classificateurs de haut niveau prêts à l’emploi qui nécessitent une configuration minimale pour fonctionner. Nous allons d’abord entraîner DNNClassifier en utilisant ensemble de données avec des nombres positifs, négatifs et zéro – avec les « étiquettes » correctes. Au niveau humain, un ensemble de données est un ensemble de nombres avec des résultats de classification (étiquettes) :

10 – positif
-22 – négatif
0 – zéro
42 – positif
… autres numéros avec classification

Ensuite, la formation commence, après quoi vous pouvez saisir des nombres qui n’étaient même pas inclus dans l’ensemble de données – c’est à dire. le réseau de neurones doit les identifier correctement.
Vous trouverez ci-dessous le code complet du classificateur avec un générateur d’ensembles de données pour la formation et les données d’entrée :

import tensorflowimporter itertoolsimporter aléatoirede heure heure d'importationclasse ClassifiedNumber :__number = 0__classifiedAs = 3def __init__(soi, nombre) :soi.__numéro =numéroif numéro == 0 :soi.__classifiedAs = 0 # zéroNuméro elif > 0 :soi.__classifiedAs = 1 # positifNuméro elif < 0 :soi.__classifiedAs = 2 # négatifdef number(soi) :return self.__numérodef classifiedAs(soi) :return self.__classifiedAsdef classifiedAsString(classifiedAs) :if classé comme == 0 :retour "Zéro"elif classéAs == 1 :retour "Positif"elif classéAs == 2 :return "Negative"def trainDatasetFunction() :trainNumbers = []trainNumberLabels = []pour i in plage(-1000, 1001) :numéro = ClassifiedNumber(i)trainNumbers.append(number.number())trainNumberLabels.append(number.classifiedAs())return ( {"number" : trainNumbers } , trainNumberÉtiquettes)def inputDatasetFunction() :global randomSeedrandom.seed(randomSeed) # pour obtenir le même résultatnombres = []pour i in plage(0, 4) :nombres.append(random.randint(-9999999, 9999999))return {"number" : nombres }def main() :print("Test de classificateur de nombres TensorFlow Positif-Négatif-Zéro par demensdeum 2017 (demensdeum@gmail. com)")maximalClassesCount = len(set< /span>(trainDatasetFunction()[1])) + 1numberFeature = tensorflow.feature_column. numeric_column("numéro")classificateur = tensorflow.estimateur. DNNClassifier(feature_columns = [numberFeature], Hidden_units = [10, 20, 10], n_classes = maximalClassesCount)générateur = classificateur.train(input_fn = trainDatasetFunction, étapes = 1000).predict(input_fn =  inputDatasetFunction)inputDataset = inputDatasetFunction()résultats = list(itertools. islice(générateur, len(inputDatasetFunction()["numéro"])))je = 0pour résultat dans résultats :imprimer("numéro : %d classé comme %s" % (inputDataset["number"][i], classifiéAsString(result["class_ids"][0 ])))je += 1randomSeed = time()principal()

Tout commence dans la méthode main(), nous définissons la colonne numérique avec laquelle le classificateur fonctionnera – tensorflow.feature_column.numeric_column(“number”) Ensuite, les paramètres du classificateur sont définis. Il est inutile de décrire les arguments d’initialisation actuels, car l’API change chaque jour, et vous devez absolument consulter la documentation de la version installée de TensorFlow et ne pas vous fier à des manuels obsolètes.

Ensuite, la formation est lancée en indiquant une fonction qui renvoie un ensemble de données de nombres de -1 000 à 1 000 (trainDatasetFunction), avec la classification correcte de ces nombres en fonction du positif, du négatif ou du zéro. Ensuite, nous soumettons en entrée les nombres qui ne figuraient pas dans l’ensemble de données de formation – ; aléatoire de -9999999 à 9999999 (inputDatasetFunction) pour les classer.

Enfin, nous lançons des itérations en fonction du nombre de données d’entrée (itertools.islice), imprimons le résultat, l’exécutons et sommes surpris :

numéro : 4063470 classé comme positifnuméro : 6006715 classé Positifnuméro : -5367127 classé comme négatifnuméro : -7834276 classé comme négatif

IL EST VIVANT

Pour être honnête, je suis toujours un peu surpris que le classificateur *comprenne* même les nombres que je ne lui ai pas enseignés. J’espère qu’à l’avenir je comprendrai le sujet de l’apprentissage automatique plus en détail et qu’il y aura plus de tutoriels.

GitLab :
https://gitlab.com/demensdeum/MachineLearning

Liens :
https://developers.googleblog.com/2017/09/introducing-tensorflow-datasets.html
https://www.tensorflow.org/versions/master/api_docs/python/tf/estimator/DNNClassifier

Briser le Bitcoin

Cette note n’est pas un appel à l’action ; je vais décrire ici les aspects faibles et potentiellement dangereux de la technologie Bitcoin et blockchain.

Centre vulnérable

Le principe de fonctionnement du Bitcoin et de la blockchain est de stocker et de modifier une base de données commune, dont une copie complète est stockée par chaque participant au réseau. Le système semble décentralisé parce que… il n’existe pas d’organisation/serveur unique sur lequel la base de données est stockée. Aussi, la décentralisation est présentée comme le principal avantage de la blockchain ; elle garantit que rien n’arrivera à vos bitcoins à votre insu.


Le principe du blocage de la peste de Elkin

Pour que la blockchain fonctionne, il est nécessaire de s’assurer que chaque utilisateur télécharge la dernière copie de la base de données blockchain et travaille avec elle selon certaines règles. Ces règles incluent la mise en œuvre du principe du minage de Bitcoin, consistant à recevoir un pourcentage de chaque transaction lors de la confirmation (frais de transaction) du transfert de fonds d’un portefeuille à un autre. L’utilisateur ne peut pas tirer 1 000 000 de bitcoins pour lui-même et acheter quelque chose avec, car… Pour les autres utilisateurs, le montant d’argent sur son compte restera inchangé. La possibilité de retirer des fonds du portefeuille de quelqu’un d’autre uniquement dans votre propre base de données est également exclue. ce changement ne sera pas reflété chez les autres utilisateurs de Bitcoin et sera ignoré.
La vulnérabilité de l’implémentation actuelle est que le portefeuille Bitcoin est situé sur le serveur github qui bloque complètement les slogans publicitaires sur la décentralisation. Pas de téléchargement de portefeuille à partir d’un seul centre – Sur le site Web du développeur, il est impossible de travailler avec Bitcoin, c’est-à-dire qu’à tout moment, les développeurs ont un contrôle total sur le réseau. Ainsi, la technologie blockchain elle-même est décentralisée, mais le client permettant de travailler avec le réseau est téléchargé à partir d’un centre unique.
Scénario d’attaque – Disons qu’un code a été ajouté au portefeuille pour retirer tous les fonds et les retirer sur le compte de tiers, après quoi tout utilisateur de la dernière version du portefeuille perdra automatiquement tous les bitcoins (sans possibilité de récupération). Je doute que de nombreux propriétaires de portefeuilles le vérifient et le construisent à partir du code source, donc les conséquences d’une telle attaque affecteront la plupart des utilisateurs.

La majorité décide

Blockchain est un réseau p2p décentralisé ; toutes les transactions sont automatiquement confirmées par les utilisateurs eux-mêmes. Scénario d’attaque – il est nécessaire d’obtenir 51 % du réseau pour ignorer les confirmations des 49 % restants, après quoi l’attaquant prend le contrôle total du Bitcoin/blockchain. Ceci peut être réalisé en connectant une puissance de calcul qui chevauche le reste. Ce scénario d’attaque est connu sous le nom d’attaque à 51 %.

Devinez-moi si vous pouvez

Lorsque vous lancez le portefeuille pour la première fois, l’ordinateur génère une paire – clé privée et publique pour assurer son bon fonctionnement. Le caractère unique de ces clés est extrêmement élevé, mais il existe une option permettant de générer des clés en utilisant le mot de code – le soi-disant “portefeuille cérébral“. Une personne stocke les clés dans sa tête ; elle n’a pas besoin de sauvegarder le fichier wallet.dat, car A tout moment, les clés peuvent être régénérées à l’aide de ce mot de code. Scénario d’attaque – l’attaquant sélectionne ou apprend le mot de code, génère une paire de clés privée-publique et prend le contrôle du portefeuille.

Copiez simplement

La paire de clés privée-publique est contenue dans le fichier wallet.dat. Tout logiciel ayant accès à ce fichier – a accès à un portefeuille Bitcoin. La protection contre une telle attaque consiste en l’ajout d’un mot de code que l’utilisateur devra mémoriser et saisir pour toutes les transactions avec le portefeuille. Après avoir ajouté le mot de passe, l’attaquant devra disposer de wallet.dat et du mot de passe pour prendre le contrôle total.
Il convient également d’ajouter que lorsque vous saisissez un mot de code, celui-ci entre dans la mémoire de l’ordinateur. Ainsi, toute vulnérabilité matérielle et/ou logicielle permettant de lire la mémoire de *quelqu’un d’autre* permettra à un logiciel antivirus de lire ce mot de code.

Erreur système

Le piratage des algorithmes de chiffrement de Bitcoin entraînera instantanément sa mort. Supposons qu’une erreur soit commise dans la mise en œuvre des algorithmes, l’attaquant qui la découvre prend le contrôle total ou partiel de la blockchain. De plus, les algorithmes de cryptage utilisés dans Bitcoin ne sont pas protégés contre le piratage par les futurs ordinateurs quantiques, leur apparition et leur mise en œuvre d’algorithmes quantiques – mettra fin à la mise en œuvre actuelle du Bitcoin. Cependant, ce problème peut être résolu en passant à des algorithmes de chiffrement post-quantique.

Utilitaires de console Nixenv Linux pour Windows

J’ai mis en place ma propre alternative à MSYS, cet ensemble comprend les utilitaires coretools + git + cmake + make + ajoute msvs msbuild à la variable d’environnement PATH. Cet ensemble d’applications est nécessaire pour les développeurs habitués à développer sur la plate-forme Linux et qui doivent créer une application pour Windows à partir de la ligne de commande à l’aide de Microsoft Visual Studio. Télécharger :

https://www.mediafire.com/file/s5yf75blfslkbym/nixenv.exe

https://www.4shared.com/file/QyjJXBaJca/nixenv.html

Installez, modifiez les chemins dans le fichier nixenv.bat et exécutez-le.

Hache de combat en acier flamboyant

À partir d’aujourd’hui, je commence à développer un éditeur pour le framework de jeu – Hache de combat en acier flamboyant.

L’éditeur vous permet d’éditer des scènes pour le framework de jeu Flame Steel Game Toolkit.
J’ai choisi le langage Kotlin basé sur Java, relativement nouveau, afin de le tester en conditions de combat.

Vous pouvez suivre le processus dans le référentiel :
https://github.com/demensdeum/FlameSteelBattleAxe

WebGL + SDL + Emscript

J’ai fini par porter Mika sur WebGL en utilisant SDL 1 et Emscripten.

Ensuite, je décrirai ce qui devait être modifié dans le code pour que la construction en JavaScript se termine avec succès.

  1. Utilisez SDL 1 au lieu de SDL 2. Il existe actuellement un portage SDL 2 pour emscripten, mais j’ai trouvé plus approprié d’utiliser le SDL 1 intégré à emscripten. Le contexte n’est pas initialisé dans la fenêtre, mais à l’aide de SDL_SetVideoMode et du flag SDL_OPENGL. Le tampon est dessiné à l’aide de la commande SDL_GL_SwapBuffers()
  2. En raison de la manière dont JavaScript boucle – le rendu est placé dans une fonction distincte et son appel périodique est effectué à l’aide de la fonction emscripten_set_main_loop
  3. L’assemblage doit également être effectué avec la clé “-s FULL_ES2=1
  4. J’ai dû abandonner la bibliothèque assimp, charger le modèle depuis le système de fichiers et charger la texture depuis le disque. Tous les tampons nécessaires ont été chargés sur la version de bureau et insérés dans le fichier c-header pour l’assemblage à l’aide d’emscripten.

Code :
https://github.com/demensdeum/OpenGLES3-Experiments/tree/master/9-sdl-gles-obj-textured-assimp-miku-webgl/mikuWebGL

Articles :
http://blog.scottlogic.com/2014/03/12/native-code-emscripten-webgl-simmer-gently.html
https://kripken.github.io/emscripten-site/docs/porting/multimedia_and_graphics/OpenGL-support.html

Modèle :
https://sketchfab.com/models/7310aaeb8370428e966bdcff414273e7