Modèle “Instantané”

Dans cet article, je décrirai le modèle « Snapshot » ; ou “Memento”

Ce modèle fait référence au modèle « comportemental ». modèles de conception.

Supposons que nous développions un éditeur graphique et que nous devions ajouter la possibilité d’annuler des actions sur une commande utilisateur. Il est également très important que les composants du système n’aient pas accès à l’état interne des « actions » annulées lors de l’implémentation de ce modèle ; les autres composants du système n’ont accès qu’à l’objet instantané sans possibilité de le modifier. son état interne, fournissant une interface externe claire et simple. Pour résoudre ce problème, le modèle « Snapshot » est utilisé. ou “Gardien”.

Exemple de travail “Snapshot” présenté ci-dessous :


Lorsque vous cliquez dessus, un sprite apparaît, lorsque vous cliquez sur la flèche courbée, l’action est annulée – Le sprite disparaît. L’exemple se compose de trois classes :

  1. Toile sur laquelle les sprites et l’interface graphique sont affichés.
  2. Contrôleur d’écran, il traite les clics et contrôle la logique de l’écran.
  3. Les états du canevas qui persistent à chaque modification sont annulés si nécessaire à l’aide du contrôleur d’écran.

Dans le contexte du modèle “Snapshot” les cours sont :

  1. Toile – source, les états de cette classe sont enregistrés sous forme de « instantanés », pour une restauration ultérieure sur demande. De plus, la source doit être capable de restaurer l’état lors du transfert d’un « instantané » vers celle-ci.
  2. Contrôleur – dépositaire, cette classe sait comment et quand enregistrer/annuler les états.
  3. État – instantané, une classe qui stocke l’état de la source, ainsi que des informations sur la date ou un index à partir duquel l’ordre de restauration peut être établi avec précision.

Une caractéristique importante du modèle est que seule la source doit avoir accès aux champs internes de l’état enregistré dans l’instantané ; cela est nécessaire pour protéger les instantanés des modifications venant de l’extérieur (des développeurs expérimentés qui souhaitent modifier quelque chose en contournant l’encapsulation). , brisant la logique du système). Pour implémenter l’encapsulation, des classes intégrées sont utilisées et, en C++, elles utilisent la possibilité de spécifier des classes amies. Personnellement, j’ai implémenté une version simple sans encapsulation pour Rise et en utilisant Generic lors de l’implémentation pour Swift. Dans ma version – Memento donne son état interne uniquement aux entités du même état de classe :

Sources

https://refactoring.guru/design-patterns/memento

Code source

https://gitlab.com/demensdeum/patterns/< /p>

Modèle de visiteur

Dans cet article, je décrirai un modèle de conception appelé « Visiteur » ; ou “Visiteur”
Ce modèle appartient au groupe des Modèles comportementaux.

Trouvons un problème

Ce modèle est principalement utilisé pour contourner la limitation de l’envoi unique dans les langues à liaison précoce.

Alice X par NFGPhoto (CC-2.0)
Créons une classe/protocole abstrait Band, créons une sous-classe de MurpleDeep, créons une classe Visitor avec deux méthodes – un pour afficher n’importe quel descendant de Band sur la console, le second pour afficher n’importe quel MurpleDeep, l’essentiel est que les noms (signatures) des méthodes soient les mêmes et que les arguments ne diffèrent que par classe. En utilisant la méthode d’impression intermédiaire avec l’argument Band, nous créons une instance de Visitor et appelons la méthode de visite pour MurpleDeep.
Vous trouverez ci-dessous le code en Kotlin :

Le résultat sera “Ceci est la classe Band“

Comment est-ce possible ?!

La raison pour laquelle cela se produit est décrite avec des mots intelligents dans de nombreux articles, y compris en russe, mais je vous suggère d’imaginer comment le compilateur voit le code, peut-être que tout deviendra clair tout de suite :

Résoudre le problème

Il existe de nombreuses solutions pour résoudre ce problème. Nous examinerons ensuite une solution utilisant le modèle Visiteur.
Nous ajoutons la méthode accept avec l’argument Visitor à la classe/protocole abstrait, appelons Visitors.visit(this) à l’intérieur de la méthode, puis ajoutons une substitution/implémentation de la méthode accept à la classe MurpleDeep, violant de manière décisive et calme DRY, en écrivant à nouveau visiteur.visit(this).< br />Code final :

Sources

https://refactoring.guru/ru/ modèles de conception/double expédition des visiteurs

Code source

https://gitlab.com/demensdeum/patterns

Modèle de poids mouche

Dans cet article, je décrirai le modèle structurel « Léger » ; ou « Opportuniste » (Poids mouche)
Ce modèle appartient au groupe des Modèles structurels.

Regardons un exemple du fonctionnement du modèle ci-dessous :


Pourquoi est-ce nécessaire ? Pour économiser de la RAM. Je suis d’accord qu’à l’heure de l’utilisation généralisée de Java (qui consomme du CPU et de la mémoire pour rien), ce n’est plus si important, mais cela vaut la peine d’être utilisé.
Dans l’exemple ci-dessus, seuls 40 objets sont générés, mais si vous augmentez le nombre à 120 000, la consommation de mémoire augmentera en conséquence.
Examinons la consommation de mémoire sans utiliser le modèle flyweight dans le navigateur Chromium :

Sans utiliser de modèle, la consommation de mémoire est d’environ 300 Mo.

Ajoutons maintenant un modèle à l’application et voyons la consommation de mémoire :

En utilisant le modèle, la consommation de mémoire est d’environ 200 Mo, nous avons donc économisé 100 Mo de mémoire dans l’application de test ; dans les projets sérieux, la différence peut être beaucoup plus grande.

Comment ça marche ?

Dans l’exemple ci-dessus, nous dessinons 40 chats, ou pour plus de clarté, 120 000. Chaque chat est chargé en mémoire sous forme d’image png, puis dans la plupart des rendus, il est converti en bitmap pour le rendu (en fait bmp), ceci est fait pour la vitesse, car un png compressé prend très longtemps à rendre. Sans utiliser le modèle, nous chargeons 120 000 images de chats dans la RAM et dessinons, mais lorsque nous utilisons le modèle « léger » ; nous chargeons un chat en mémoire et le dessinons 120 000 fois avec différentes positions et transparence. Toute la magie réside dans le fait que nous implémentons les coordonnées et la transparence séparément de l’image du chat ; lors du rendu, le rendu prend un seul chat et utilise un objet avec des coordonnées et une transparence pour un rendu correct.

À quoi ça ressemble dans le code ?

Voici des exemples pour le langage Rise< /p>

Sans utiliser de modèle :


L’image du chat est chargée séparément pour chaque objet de la boucle – catImage.

Utilisation du modèle :

Une image d’un chat est utilisée par 120 000 objets.

Où est-il utilisé ?

Utilisé dans les frameworks GUI, par exemple la « réutilisation » d’Apple. (réutilisation) Cellules du tableau UITableViewCell, ce qui élève la barrière à l’entrée pour les débutants qui ne connaissent pas ce modèle. Également couramment utilisé dans le développement de jeux.

Code source

https://gitlab.com/demensdeum/patterns/< /p>

Sources

https://refactoring.guru/ru/design-patterns/ poids mouche
http://gameprogrammingpatterns.com/flyweight.html

Le Bon, la Brute et le Truand Singleton

Dans cette note, je décrirai mon expérience et celle de mes collègues lorsque j’ai travaillé avec le modèle Singleton (Singleton dans la littérature étrangère), tout en travaillant sur divers projets (réussis et moins réussis). Je décrirai pourquoi je pense personnellement que ce modèle ne peut être utilisé nulle part, et je décrirai également quels facteurs psychologiques dans l’équipe influencent l’intégration de cet anti-modèle. Dédié à tous les développeurs déchus et paralysés qui essayaient de comprendre pourquoi tout a commencé lorsqu’un des membres de l’équipe a amené un petit chiot mignon, facile à manipuler, ne nécessitant pas de soins ni de connaissances particulières pour en prendre soin, et s’est terminé avec la bête élevée. prendre votre projet en otage, nécessite de plus en plus d’heures de travail et ronge les nerfs de l’utilisateur, votre argent et crée des chiffres absolument monstrueux pour évaluer la mise en œuvre de choses apparemment simples des choses.


Wolf in sheep’s clothing by SarahRichterArt

L’histoire se déroule dans un univers alternatif, toutes les coïncidences sont aléatoires…

Carotter un chat à la maison avec Cat@Home

Toute personne, parfois dans la vie, a un désir irrésistible de caresser un chat. Les analystes du monde entier prédisent que la première startup qui a créé une application pour la livraison et la location de chats deviendra extrêmement populaire et sera rachetée dans un avenir proche par Moogle pour des milliards de dollars. Bientôt, cela arrive – un gars de Tioumen crée l’application Cat@Home et devient bientôt un milliardaire, la société Moogle obtient une nouvelle source de profit et des millions de personnes stressées ont l’opportunité de commandez un chat chez eux pour un repassage supplémentaire et calmez-vous.

Attaque des clones

Alexey Goloborodko, un dentiste extrêmement riche de Mourmansk, impressionné par un article de Forbes sur Cat@Home, décide qu’il veut aussi devenir astronomiquement riche. Pour atteindre cet objectif, grâce à ses amis, il trouve une entreprise à Goldfield – un fournisseur de services. Wakeboard DevPops, qui fournit des services de développement de logiciels, leur commande le développement d’un clone Cat@Home.

Équipe gagnante

Le projet s’appelle Fur&Pure, confié à une talentueuse équipe de développement de 20 personnes ; Concentrons-nous ensuite sur une équipe de développement mobile de 5 personnes. Chaque membre de l’équipe obtient sa part du travail, armé d’agile et de Scrum, l’équipe termine le développement dans les délais (en six mois), sans bugs, publie l’application dans l’iStore, où elle est notée 5 par 100 000 utilisateurs, il y en a beaucoup des commentaires sur la qualité de l’application et l’excellence du service (univers alternatif après tout). Les chats sont repassés, l’application est sortie, tout semble bien se passer. Cependant, Moogle n’est pas pressé d’acheter une startup pour des milliards de dollars, car non seulement des chats mais aussi des chiens sont déjà apparus dans Cat@Home.

Le chien aboie, la caravane avance

Le propriétaire de l’application décide qu’il est temps d’ajouter des chiens à l’application, demande une évaluation à l’entreprise et dispose d’environ au moins six mois pour ajouter des chiens à l’application. En fait, l’application sera réécrite à partir de zéro. Pendant ce temps, Moogle ajoutera des serpents, des araignées et des cobayes à l’application, et Fur&Pur ne recevra que des chiens.
Pourquoi est-ce arrivé ? Le manque d’architecture d’application flexible est à l’origine de tout ; l’un des facteurs les plus courants est l’anti-modèle Singleton.

Qu’est-ce qui ne va pas ?

Pour commander un chat à la maison, le consommateur doit créer une demande et l’envoyer au bureau, où le bureau la traitera et enverra un coursier avec le chat, le coursier recevra déjà le paiement du service.
L’un des programmeurs décide de créer une classe « Cat Application » ; avec les champs nécessaires, introduit cette classe dans l’espace d’application global via un singleton. Pourquoi fait-il ça ? Pour gagner du temps (une économie d’un centime d’une demi-heure), car il est plus facile de rendre une application publique que de réfléchir à l’architecture de l’application et d’utiliser l’injection de dépendances. Ensuite, d’autres développeurs récupèrent cet objet global et y lient leurs classes. Par exemple, tous les écrans eux-mêmes accèdent à l’objet global “Cat Request” et afficher les données sur l’application. En conséquence, une telle application monolithique est testée et publiée.
Tout semble aller bien, mais tout à coup, un client apparaît avec l’obligation d’ajouter des demandes de chiens à l’application. L’équipe commence frénétiquement à évaluer combien de composants du système seront affectés par ce changement. A l’issue de l’analyse, il s’avère qu’il faut refaire de 60 à 90% du code afin d’apprendre à l’application à accepter non seulement “Request For Cat” mais aussi “Demande pour un Chien”, il est déjà inutile d’évaluer l’ajout d’autres animaux à ce stade, pour en gérer au moins deux.

Comment empêcher le singleton

Tout d’abord, au stade de la collecte des exigences, indiquez explicitement la nécessité de créer une architecture flexible et extensible. Deuxièmement, il convient de procéder en parallèle à un examen indépendant du code du produit, avec une recherche obligatoire des points faibles. Si vous êtes développeur et que vous aimez les singletons, alors je vous suggère de reprendre vos esprits avant qu’il ne soit trop tard, sinon les nuits blanches et les nerfs à vif sont garantis. Si vous travaillez sur un projet existant comportant de nombreux singletons, essayez de vous en débarrasser le plus rapidement possible, ainsi que du projet.
Vous devez passer de l’anti-modèle d’objets/variables globaux singletons à l’injection de dépendances – le modèle de conception le plus simple dans lequel toutes les données nécessaires sont fournies à une instance d’une classe au stade de l’initialisation, sans qu’il soit nécessaire de les lier à l’espace global.

Sources

https://stackoverflow. com/questions/137975/what-is-so-bad-about-singletons
http://misko.hevery.com/2008/08/17/singletons-are-pathological-liars/
https://blog.ndepend.com/singleton-pattern-costs/

Rapport de développement 1 de Death Mask

Nouvelle section non permanente « Journaux des développeurs » ; ou Dev Diary dans un style étranger.
Le développement du jeu Death-Mask bat son plein, le logo du moteur a été ajouté pour les jeux Flame Steel Engine 2019, écran de sélection de la carte initiale par île (vert, rouge, noir, blanc), sortie de textures pour les murs, le plafond, le sol du labyrinthe, augmentation de la taille de l’aire de jeu.


Carte de la ville de la zone rouge

Ensuite, nous prévoyons d’ajouter des modèles 3D pour l’environnement, au lieu des sprites de style Doom, et nous prévoyons d’ajouter des modèles pour les armes, les boîtes, les ennemis et les amis. Dans le gameplay, il est prévu d’ajouter de la monnaie, des magasins, la possibilité d’acheter des parties de la carte du jeu indiquant des endroits intéressants avec du butin et l’emplacement possible du « Masque de la mort ». Je souhaite également ajouter la possibilité d’embaucher des compagnons pour voyager à travers le cyber-labyrinthe.
Suivez l’actualité.

Swift 4.2.3 – Ubuntu 18.10

Créer Swift avec les bibliothèques nécessaires pour fonctionner sur Ubuntu 18.10. Dernière version disponible sur le site Apple – pour Ubuntu 18.04. Basé sur l’assemblage du site officiel avec l’ajout de bibliothèques d’Ubuntu 18.04. Ajout également d’un exemple de script pour ajouter PATH et LD_LIBRARY_PATH pour le terminal bash :
http://www.mediafire.com/file/lrs74mvoj3fti03/swift4.2.3.ubuntu.18.10.x86_64.tar.gz/file

Langage déclaratif Zakaz

Je présente à votre attention un langage de programmation purement déclaratif – Zakaz. L’idée principale du nouveau langage – l’application contient des commandes d’exécution écrites sous forme libre qui doivent être exécutées par des « exécuteurs ». Si aucun « interprète » ; ne peut pas exécuter la commande, l’exécution du programme s’arrête. Les candidatures sont appelées spécifications techniques (tez) et doivent avoir une extension .tez. La syntaxe Zakaz nécessite deux règles :

  • Chaque commande commence sur une nouvelle ligne
  • Chaque commande doit être écrite dans un langage formel compréhensible par les humains

Exemple Hello World.tez :

Afficher le texte "Hello World" à l'écranAfficher le texte "Exemple Zakaz 'tez'" à l'écran

Un exemple de spécification affichant une description du principe de fonctionnement et d’ouverture du site http://demensdeum.com dans le navigateur Firefox

Afficher le texte "Afficher la démo du site Web" à l'écranAfficher "Vous devez installer Firefox sur votre système pour exécuter ce 'tez', et il doit être appelable via \"system\" Fonction C" texte à l'écranAfficher "Il devrait également y avoir \"FirefoxPerformer\" attribué au Zakaz Runtime, veuillez consulter le manuel pour plus d'informations" texte à l'écranAfficher le site Web avec l'adresse "http://demensdeum.com" dans Firefox

Vous devez exécuter l’exemple ci-dessus avec l'”exécuteur” ; FirefoxPerformer, capable de traiter la dernière commande pour afficher un site via Firefox

./ZakazRuntime openDemensdeumSite.tez FirefoxPerformer

Pour implémenter votre exécuteur, vous devez l’implémenter en tant que bibliothèque dynamique en utilisant la classe abstraite ZakazRuntime::Performer, et le renvoyer avec un pointeur intelligent de la méthode de fonction globale createPerformer(). Vous pouvez utiliser l’implémentation de FirefoxPerformer comme exemple.

Code source

https://gitlab.com/demensdeum/zakaz

С++ 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