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

Flattern wie Michelle

[Spüren Sie die Kraft der künstlichen Intelligenz]
In diesem Beitrag werde ich Ihnen sagen, wie Sie die Zukunft vorhersagen.

In der Statistik gibt es eine Klasse von Problemen – Zeitreihenanalyse. Wenn Sie ein Datum und den Wert einer bestimmten Variablen haben, können Sie den Wert dieser Variablen in der Zukunft vorhersagen.
Zuerst wollte ich eine Lösung für dieses Problem implementieren, indem ich TensorFlow, aber die Bibliothek Prophet von Facebook.
Prophet ermöglicht es Ihnen, eine Prognose basierend auf Daten (csv) zu erstellen, die Datumsspalten (ds) und Variablenwertspalten (y) enthalten. Wie man damit arbeitet, erfahren Sie in der Dokumentation auf der offiziellen Website im Abschnitt Schnellstart
Als Datensatz habe ich einen CSV-Upload von der Website https://www.investing.com, bei der Implementierung habe ich R-Sprache und Prophet-API für ihn. Mir hat R sehr gut gefallen, weil seine Syntax die Arbeit mit großen Datenmengen vereinfacht, ein einfacheres Schreiben ermöglicht und weniger Fehler macht als bei der Arbeit mit herkömmlichen Sprachen (Python), da man mit Lambda-Ausdrücken arbeiten müsste, und in R haben Sie bereits alle Lambda-Ausdrücke.
Um die Daten nicht für die Verarbeitung vorzubereiten, habe ich das Paket anytime, das Zeichenfolgen ohne Vorverarbeitung in ein Datum konvertieren kann. Die Konvertierung von Währungszeichenfolgen in Zahlen erfolgt mit dem readr-Paket .

Als Ergebnis erhielt ich eine Prognose, wonach Bitcoin bis Ende 2019 8.400 US-Dollar kosten wird und der Dollarkurs 61 Rubel betragen wird. Sollten wir diesen Prognosen Glauben schenken? Persönlich denke ich, dass es sich nicht lohnt, weil… Man kann mathematische Methoden nicht anwenden, ohne ihr Wesen zu verstehen.

Quellen

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

Quellcode

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

Tesla spricht

In diesem Beitrag beschreibe ich den Prozess der Erstellung eines Zitatgenerators.

TL;DR

Für Schulung und Textgenerierung – Verwenden Sie die Bibliothek textgenrnn, um Phrasen zu filtern, müssen Sie die Rechtschreibprüfung mit hunspell und seine Bibliotheken für C/Python. Nach dem Training in Colaboratory, Sie können mit der Textgenerierung beginnen. Etwa 90 % des Textes werden erstellt völlig unlesbar, die restlichen 10 % enthalten jedoch ein wenig Bedeutung, und mit manueller Änderung sehen die Phrasen recht gut aus.
Am einfachsten ist es, ein vorgefertigtes neuronales Netzwerk in Colaboratory zu starten:
https://colab.research.google.com/drive/1-wbZMmxvsm3SoclJv11villo9VbUesbc(öffnet sich in einem neuen Tab)”>https://colab.research.google.com/drive/1-wbZMmxvsm3SoclJv11villo9VbUesbc

Quellcode

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

Quellen

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

Wie viele Fehler hast du da?

Auf Hacker News habe ich einen sehr interessanten Artikel gefunden, in dem der Autor die Verwendung von vorschlägt Petersen-Lincoln-Methode, die von Biologen verwendet wird, um die Population von Vögeln, Affen und anderen Tieren zu zählen, zum *Trommelwirbel* Zählen von Käfern in der Anwendung.

Käfer im natürlichen Lebensraum – Bigfoot-Sichtung von Derek Hatfield

Die Methode ist sehr einfach, wir nehmen zwei Ornithologen, finden sie Vögel einer bestimmten Art, ihre Aufgabe – Bestimmen Sie die Populationsgröße dieser Vögel. Die gefundenen Vögel werden von beiden Ornithologen markiert, dann wird die Anzahl der häufigen Vögel berechnet, in die Lincoln-Indexformel eingesetzt und wir erhalten die ungefähre Populationsgröße.
Nun zu den Bewerbungen – Die Methode ist auch sehr einfach: Wir nehmen zwei Qualitätssicherungskräfte und sie finden Fehler in der Anwendung. Nehmen wir an, ein Tester hat 10 Fehler gefunden (E1) und der zweite Tester hat 20 Fehler gefunden (E2). Jetzt nehmen wir die Anzahl der Gesamtfehler – 3 (S), dann erhalten wir mit der Formel den Lincoln-Index:

Dies ist eine Prognose der Anzahl der Fehler in der gesamten Anwendung. Im angegebenen Beispiel sind es etwa 66 Fehler.

Schnelles Beispiel

Ich habe einen Prüfstand implementiert, um die Methode zu testen, Sie können ihn hier sehen:
https://paiza.io/projects/AY_9T3oaN9a-xICAx_H4qw?language=swift

Parameter, die geändert werden können:

let aliceErrorFindProbability = 20 – Prozentsatz der von QA Alice gefundenen Fehler (20 %)
let bobErrorFindProbability = 60 – Prozentsatz der von QA Bob gefundenen Fehler (60 %)
let currentBugsCount = 200 – Wie viele Fehler gibt es wirklich in der Anwendung?

Im letzten Durchlauf habe ich folgende Daten erhalten:
Anzahl der Schätzungsfehler: 213
Tatsächliche Anzahl der Fehler: 200

Das heißt, es gibt 200 Fehler in der Anwendung, der Lincoln Index gibt eine Prognose – 213:
„Alice hat 36 Fehler gefunden.“
„Bob hat 89 Fehler gefunden.“
“Anzahl häufiger Fehler: 15”
—
Anzahl der Schätzungsfehler: 213
Tatsächliche Anzahl der Fehler: 200

Schwächen

Diese Methode kann verwendet werden, um die Anzahl der Fehler in der Anwendung in allen Phasen der Entwicklung zu bewerten. Im Idealfall sollte die Anzahl der Fehler sinken. Zu den Schwächen der Methode gehört unter anderem der menschliche Faktor, da die Anzahl der von zwei Testern gefundenen Fehler unterschiedlich sein sollte und unterschiedliche Fehler gefunden wurden häufige Fehler müssen gefunden werden, andernfalls funktioniert die Methode nicht (null häufige Fehler – Division durch Null)< br />Außerdem erfordert ein Konzept wie häufige Fehler die Anwesenheit eines Experten, um ihre Gemeinsamkeiten zu verstehen.

Quellen

Wie viele Fehler müssen noch gefunden werden? – John D. Cook, PhD, Präsident
The thrill of the chase – Brian Hayes

Quellcode

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

Zahnräder schleifen

Oh Muse, wie schwer ist es manchmal, dich zu erwischen.
Die Entwicklung von Death-Mask und zugehörigen Frameworks (Flame Steel Core, Game Toolkit usw.) wird für mehrere Monate ausgesetzt, um über den künstlerischen Teil des Spiels, Musik, Sound und Gameplay zu entscheiden.
Pläne – Erstellen Sie einen Editor für das Flame Steel Game Toolkit, schreiben Sie einen Interpreter für Spielskripte (basierend auf der Rise-Syntax) und implementieren Sie das Death-Mask-Spiel für so viele Plattformen wie möglich.
Die schwierigste Etappe ist geschafft – In der Praxis hat sich die Möglichkeit bewährt, eine eigene plattformübergreifende Spiel-Engine, eine eigene IDE und eine Reihe von Bibliotheken zu schreiben.
Ich bin dabei, ein wirklich durchdachtes und interessantes Projekt zu erstellen. Bleiben Sie dran.

Totenmaske im öffentlichen Bereich

Ab heute geht das Spiel Death-Mask in den Open Access – Sie können den Fortschritt der Spielimplementierung unter dem Link verfolgen: (Wow!)
[Death-Mask Wild]

Aktuelle Version – 0.1 enthält grundlegende Pfeilsteuerungen, WSAD, Generierung von Karten, Gegenständen (einschließlich der Totenmaske!), Rendering.
Es gibt noch viel zu tun und ich bin sehr an Ihrem Feedback interessiert – So können Sie Kommentare auf der Seite mit der Wild-Version des Spiels schreiben.
In der endgültigen Version endet das Spiel, nachdem der Spieler den Gegenstand gefunden hat – Totenmaske
Viel Spaß beim Testen : )
—
Авторы ресурсов

Hangar18-Quellcode-Indizierungsdienstprogramm

Hangar18 – In Rust geschriebenes C++-Quellcode-Indizierungsdienstprogramm. Dieses Dienstprogramm implementiert die Funktionalität „Gehe zur Definition“. in der Sabre-Plus-IDE.
Die Eingabe in das Dienstprogramm ist der absolute Pfad zum Quellcodeverzeichnis und die Deklarationszeile, die gefunden werden muss. Die Ausgabe ist eine grep-ähnliche Ausgabe.

Quellcode:
https://gitlab.com/demensdeum/hangar18

Taytay überwacht den Status von Git-Repositories

Ich präsentiere Ihnen Taytay – ein Dienstprogramm zur Überwachung des Status von Git-Repositorys für die Swift-Sprache. Derzeit kann Swift auf allen gängigen Desktop-Betriebssystemen installiert werden. Für Ubuntu empfehle ich die Verwendung von Swiftenv. Taytay mit dem Dienstprogramm git-cola, aber Sie können die Quelle bearbeiten und in jedes andere Programm ändern.

Quellcode:
https://gitlab.com/demensdeum/taytay

Wir haben Malevich, Black Squares OpenGL geschlagen

Malevich kommt regelmäßig jedem Entwickler auf OpenGL. Dies geschieht unerwartet und mutig.

Heute werde ich beschreiben, aus welchem Grund ich von einem schwarzen Quadrat besucht wurde.

Verwenden Sie Tools

Für das Debuggen von OpenGL haben mir zwei Tools geholfen: renderdoc und und Apitrace . Renderdoc – Tool zum Debuggen des OpenGL -Rendering -Prozesses können Sie alles anzeigen – Scheitelpunkte, Shader, Texturen, Schuldennachrichten des Fahrers. Apitrace – Ein Werkzeug für die Verfolgung von Herausforderungen einer grafischen API macht einen Dump -Anruf und zeigt Argumente an. Es gibt auch eine großartige Gelegenheit, zwei Dumps über WDIFF (oder ohne, aber nicht so bequem) zu vergleichen

Überprüfen Sie, mit wem Sie arbeiten

Ich habe ein Betriebssystem Ubuntu 16.10 mit alten Abhängigkeiten SDL2, GLM, Anlage, Glew. In der neuesten Version von Ubuntu 18.04 erhalte ich die Zusammenstellung des Spiels Todesmaske Das zeigt nichts auf dem Bildschirm (nur ein Black Square). Wenn Sie Chroot und Assembly bei 16.10 i verwenden, erhalte ich eine Arbeitsanordnung des Spiels mit Graphics .

In Ubuntu 18.04

scheint etwas gebrochen zu sein

ldd zeigte die Linkka zu identischen Bibliotheken SDL2, GL. Als ich einen nicht bearbeiteten Build in Renderdoc fuhr, sah ich Müll am Eingang zum Scheitelpunkt -Shader, aber ich brauchte eine solide Bestätigung. Um den Unterschied zwischen der Binarik zu verstehen, habe ich sie beide durch apitrace gefahren. Der Vergleich von Dumps hat mir gezeigt, dass die Versammlung auf einem frischen Ubunta das Programm der Aussichten in OpenGL bricht und tatsächlich Müll dorthin schickt:

Matrizen sammeln sich in der GLM -Bibliothek. Nach dem Kopieren von GLM von 16.04 – Ich habe wieder den Arbeitsaufbau des Spiels bekommen. Das Problem war der Unterschied in der Initialisierung einer einzelnen Matrix in GLM 9.9.0, es ist notwendig, das Argument MAT4 (1.0F) im Konstruktor eindeutig anzuzeigen. Nachdem ich die Initialisierung und geändert habe, indem ich der Autor der Bibliothek abgeschrieben habe. “Noopener”> Tests für FSGL . Beim Schreiben, den ich in FSGL fand, werde ich sie weiter beschreiben.

Bestimmen Sie, wer im Leben ist

Für die richtige Arbeit mit OpenGL müssen Sie freiwillig gewaltsam den Kontext einer bestimmten Version anfordern. So sucht es nach SDL2 (Sie müssen die Version streng einsetzen, bevor Sie den Kontext initialisieren): 


 SDL_GL_SETTRTRIBUT (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);

zum Beispiel funktioniert Renderdoc nicht mit Kontexten unter 3.2. Ich möchte feststellen, dass nach dem Umschalten des Kontextes eine hohe Wahrscheinlichkeit besteht, dass der gleiche schwarze Bildschirm angezeigt wird. Warum?
Denn der -Kontext von OpenGL 3.2 muss das Vorhandensein von VAO -Puffer erfordern, ohne dass 99% der grafischen Treiber nicht funktionieren. Fügen Sie es einfach hinzu: 


 GlGenvertexArrays ( 1 ,  &  vao);

Glbindvertexaray (vao);

schlaf nicht, friere ein.

Ich habe auch ein interessantes Problem auf Kubuntu getroffen, anstatt auf ein schwarzes Quadrat wurde mir transparent angezeigt, und Manchmal wurde alles richtig gemacht. Ich fand die Lösung für dieses Problem beim Stack -Überlauf:
https://stackoverflow.com/questions/38411515/sdl2-opengl-window-appears-semi-transparent-sometimes

Der FSGL -Test -Render -Code war ebenfalls vorhanden Schlaf (2S) ; Also erhielt ich auf dem Xubuntu und Ubuntu das richtige Rendern und schickte den Antrag in den Schlaf, aber auf Kubuntu erhielt ich einen transparenten Bildschirm in 80% des Starts von Delphin und 30% der Starts und Terminal. Um dieses Problem zu lösen, fügte ich nach einer Sdlevent -Umfrage in jedem Frame Rendering hinzu, wie in der Dokumentation empfohlen.

Testcode:
https://gitlab.com/demensdeum/FSGLtests/blob/master/renderModelTest/

Sprechen Sie mit dem Treiber

OpenGL unterstützt den Kommunikationskanal zwischen der Anwendung und dem Treiber, um ihn zu aktivieren. .
Hier kann ein Beispiel für die Initialisierung aufgenommen werden:
https://github.com/rock-core/gui-vizkit3d/blob/master/src/EnableGLDebugOperation.cpp

Hab keine Angst, sieh zu, wie es wächst

In diesem Beitrag werde ich über meine Missgeschicke mit shared_ptr Smart Pointern sprechen. Nachdem ich die Next-Level-Generation in meinem Spiel Death-Mask implementiert hatte, bemerkte ich eine Erinnerung Leck . Jede neue Stufe erhöhte den verbrauchten RAM um + 1 Megabyte. Es ist offensichtlich, dass einige Objekte im Speicher verblieben und nicht freigegeben wurden. Um diesen Umstand zu korrigieren, war es notwendig, die korrekte Implementierung von Ressourcen bei Überlastung des Levels zu implementieren, was offenbar nicht geschehen ist. Da ich intelligente Zeiger verwendet habe, gab es mehrere Möglichkeiten, dieses Problem zu lösen. Die erste bestand darin, den Code manuell zu überprüfen (lang und langweilig), während die zweite darin bestand, die Fähigkeiten des lldb-Debuggers und des libstdc++-Quellcodes auf die Möglichkeit einer automatischen Nachverfolgung zu untersuchen Zähleränderungen.

Im Internet liefen alle Ratschläge darauf hinaus, den Code manuell zu überprüfen, ihn zu reparieren und sich selbst mit Peitschenhieben zu schlagen, nachdem man die problematische Codezeile gefunden hatte. Es wurde auch vorgeschlagen, ein eigenes System für die Arbeit mit dem Speicher zu implementieren, wie es alle großen Projekte tun, die seit den 90er und 2000er Jahren entwickelt wurden, bevor intelligente Zeiger im C++11-Standard eingeführt wurden. Ich habe versucht, Haltepunkte im Konstruktor einer Kopie aller shared_ptrs zu verwenden, aber nach mehreren Tagen passierte nichts Nützliches. Es gab die Idee, Protokollierung zur libstdc++-Bibliothek hinzuzufügen, aber der Arbeitsaufwand erwies sich als enorm.


Cowboy Bebop (1998)

Die Lösung kam mir plötzlich in Form der Verfolgung von Änderungen in der privaten Variablen shared_ptr – use_count. Dies kann mithilfe von in lldb integrierten Watchpoints erfolgen. Nach dem Erstellen eines shared_ptr über make_shared können Änderungen am Zähler in lldb mithilfe der Zeile:
verfolgt werden

watch set var camera._M_refcount._M_pi->_M_use_count

Wo “Kamera” Dies ist ein shared_ptr-Objekt, dessen Zählerstand verfolgt werden muss. Natürlich variieren die Interna von shared_ptr je nach Version von libstdc++, aber das allgemeine Prinzip ist verständlich. Nach der Installation des Watchpoints starten wir die Anwendungen und lesen den Stacktrace jeder Zähleränderung, dann schauen wir uns den Code an (sic!), finden das Problem und beheben es. In meinem Fall wurden Objekte nicht aus Cache-Tabellen und Spiellogiktabellen befreit. Ich hoffe, dass diese Methode Ihnen beim Umgang mit Lecks bei der Arbeit mit shared_ptr hilft, und ich liebe dieses Speichertool noch mehr. Viel Spaß beim Debuggen.

Spielevision Nr. 3

Die dritte Ausgabe einer nicht permanenten Kolumne über Spiele Games Vision.

Observer (PC und Konsolen, Bloober Team) – Cyberpunk-Horror von den tapferen Polen. Ein kurzer und sehr atmosphärischer Horrorfilm mit Rutger Hauer in der Hauptrolle. Als Cyberpunk-Fan gefiel mir absolut alles an dem Spiel. Nicht sehr schwierige Rätsel, charmante Pannen der Hauptfigur, Gameplay mit ruhigen Momenten gemischt mit Action, die Möglichkeit, buchstäblich in die Erinnerungen der Toten einzutauchen, eine Handlung im Ghost in the Shell-Stil + viele Anspielungen auf die Sci-Fi-Popkultur. Von den Minuspunkten – Zu viele Pannen, manchmal scheint es, dass es aufgrund ihrer Fülle unmöglich ist, sie zu spielen, außerdem wurden einige Spieler durch bestimmte Horrorelemente wütend, die so beängstigend waren, dass sie nicht weiterspielen konnten.
Bewertung: 8/10

Paradigma (Windows/OS X, Jacob Janerka) – Eine Suche, die es schafft, alles auf einmal zu parodieren und darüber zu lachen. Es gibt Spott über die UdSSR, Amerika, das Quest-Genre, Glam Rock, alte Konsolen, Menschen, Denkmäler, IT-Leute, Kegel, Computer, Frauen, Kinder, Eltern, Künstler, Liebe, Wissenschaftler, die Spieleindustrie, die Spieler selbst & #8211; Im Allgemeinen ist es unmöglich, alles aufzulisten. Absolut unvorhersehbare Handlung, absurde Atmosphäre und Kunst, keine besonders schwierigen Rätsel. Das Spiel weist seltene Bugs und Abstürze auf, einige Momente und Witze sind leicht vorhersehbar und nicht originell.
Bewertung: 9/10

Late Shift (PC und Konsolen, CtrlMovie Ltd) – interaktiver Film. Es tut mir wirklich leid, dass eine grundsätzlich gute Idee so schlecht umgesetzt wurde. Alles ist schlecht – Handlung, Mangel an Hauptdarstellern, Schauspiel, ständige Einfrierungen in der PC-Version, fast keine Variabilität (illusorisch). Es ist völlig unverständlich, wie es in den 2010er Jahren möglich war, ein Spiel mit so vielen Problemen zu veröffentlichen, denn tatsächlich handelt es sich um einen gewöhnlichen Videoplayer, das gesamte Spiel hätte im Internet, beispielsweise auf YouTube, veröffentlicht werden können, aber stattdessen wurde es verwendet Unity hat es geschafft, eine so leistungsstarke Spiel-Engine auszugleichen. Das offizielle Forum auf Steam ist Fixes, Hotfixes, Workarounds usw. gewidmet. Es gibt eine technische Katastrophe, mangelnde Benutzerunterstützung, alle Tests finden direkt auf den Spielern statt. Habe begeisterte Kritiken und Erfahrungsberichte gekauft.
Bewertung: 3/10

Rise-Programmiersprache

Ich präsentiere Ihnen meine eigene Programmiersprache namens – Aufstieg. Ein Transpiler von Rise nach JavaScript ist derzeit verfügbar.

Sie können es unter dem folgenden Link sehen und verwenden – Aufstieg in JavaScript (ECMAScript 5-Dialekt):
https://gitlab.com/demensdeum/Rise

Ich präsentiere Ihnen auch eine Demoanwendung, die vollständig in Rise geschrieben ist:

Quellcode der Rise-Demoanwendung:
https://gitlab.com/demensdeum/RiseDemoApplication

Sie können mir schreiben, wenn Sie möchten Habe ich Ideen, Vorschläge, Kommentare zur neuen Sprache?

Kern der Korruption

Das Atmen fiel mir schwer; das Helmdisplay zeigte genau eine halbe Stunde lang die Sauerstoffversorgung an. Während dieser Zeit plante Revil, das Stadtzentrum zu erreichen und die Todesmaske zu beschaffen. Überall war ein beißender grüner Nebel, hier gab es keine Luft, halbtote Menschen irrten durch die Straßen, Kreaturen, die vom Einfluss der Maske gefangen genommen wurden.
Das Geräusch von Schritten breitete sich durch die leeren Räume des verlassenen Gebäudes aus. Revil bewegte sich vorsichtig, da er nicht wusste, was ihn am gefährlichsten Ort des Technolabs erwarten würde.

Bewegen Sie sich nicht!
von M-Delcambre

Die Stadt ist seit langem von der Korruption erfasst, nicht jedoch von der irdischen, die den Geist von Politikern und Machthungrigen versklavt. Die Korruption von Death Mask übernimmt den Geist der Lebewesen, sie verlieren die Kontrolle über sich selbst und beginnen zu leben, um ihre Wünsche zu erfüllen. Alle, die unter den Einfluss gerieten, begannen zu glauben, dass sie als Ergebnis ihres Dienstes ewiges Leben erhalten würden. Um die Kontrolle zu behalten, benötigt die Maske einen ständigen Zustrom neuer Sklaven und die Eroberung neuer Gebiete mit reinen Kreaturen.

Im Nordwesten sah Revil das blaue Leuchten, von dem Alice ihm erzählte; in der Mitte befand sich ein riesiges Gebäude, das von den Technolab-Bauherren geschaffen wurde. Eine seltsame, groteske Ansammlung hervorstehender Rahmen und mechanischer Teile, als ob sie von einem Verrückten geschaffen worden wäre, hatte ein erschreckendes Aussehen.

Revil stieg aus dem Fenster des Gebäudes auf die Straße, um seine Reise fortzusetzen, als er plötzlich das laute Aufschlagen von Metallgliedern auf dem Asphalt hörte. Als er sich umdrehte, sah er den Dämon vor sich – Ein biomechanisches Wesen mit drei menschlichen Köpfen, ähnlich einer Spinne, bewegte sich langsam auf ihn zu. Ein Kreis von seltsamer, spiegelschwarzer Farbe erschien am Himmel; es war schwer, den Blick abzuwenden. Es gab ein ohrenbetäubendes Brüllen der Stadtsirene, die Sklavenkreaturen rief, um dem Dämon zu helfen. Die Situation war verdammt schlimm, aber Revil hatte für diesen Fall eine Überraschung parat…

Sabre-Plus C++ IDE

Begann mit der Entwicklung meiner eigenen IDE für C++ – Sabre-Plus. Die Hauptideen der neuen IDE – Seien Sie einfach, schnell und *hilfreich* in der Entwicklung. Derzeit ist der Quellcode unter der MIT-Lizenz auf GitHub verfügbar; Qt wird für die Arbeit mit der Benutzeroberfläche verwendet. In Zukunft plane ich, die gesamte Entwicklung im Zusammenhang mit C++ auf Sabre-Plus zu übertragen – Death-Mask wird definitiv migriert. Weitere Details zu den Punkten:

  • Einfach – Es ist geplant, nicht mehr als nötig hinzuzufügen – enthalten beispielsweise keine Quellcodeverwaltungs-Clients, integrierte Terminals und ähnliche Dinge. Die Funktionalität konzentriert sich ausschließlich auf die Codebearbeitung und Fehleranalyse. Der Editorcode sollte in einfache Klassen unterteilt werden, die ihren Teil der Arbeit korrekt erledigen (Unix-artig)
  • Schnell – betrifft sowohl die IDE-Codebasis als auch das Verhalten des Editors selbst. Alle Aktionen in der IDE sollten so schnell wie möglich sein, auch solche, die oft langwierig und komplex sind wie das Erstellen/Importieren von Projekten.
  • Helfen – Analyse typischer Fehler beim Schreiben und Kompilieren von Code. Korrigieren von Fehlern und Warnungen auf Benutzeranfrage. Geplant ist, eine Analyse des Anwendungsaufbaus auf einer bestimmten Plattform hinzuzufügen und Hilfeinformationen zur Installation der erforderlichen Bibliotheken und Komponenten anzuzeigen.

Um den Editor für Ihr Betriebssystem zu erstellen, müssen Sie das Qt 5 SDK installieren, den IDE-Code aus dem Repository herunterladen, die Datei Sabre-Plus.pro in Qt Creator öffnen und den Build ausführen:

https://github.com/demensdeum/saberplus

Einfaches TensorFlow-Beispiel

Ich präsentiere Ihnen ein einfaches Beispiel für die Arbeit mit einem Framework für die Arbeit mit Deep Learning – TensorFlow. In diesem Beispiel bringen wir einem neuronalen Netzwerk bei, positive, negative Zahlen und Nullen zu erkennen. Installation von TensorFlow und CUDA Ich sage Ihnen, diese Aufgabe ist wirklich nicht einfach)

Um Klassifizierungsprobleme zu lösen, Klassifikatoren. TensorFlow verfügt über mehrere vorgefertigte High-Level-Klassifikatoren, für deren Funktion nur eine minimale Konfiguration erforderlich ist. Zuerst trainieren wir DNNClassifier mit Datensatz mit positiven, negativen Zahlen und Null – mit den richtigen „Beschriftungen“. Auf menschlicher Ebene ist ein Datensatz eine Reihe von Zahlen mit Klassifizierungsergebnissen (Beschriftungen):

10 – positiv
-22 – negativ
0 – Null
42 – positiv
… andere Zahlen mit Klassifizierung

Als nächstes beginnt das Training. Anschließend können Sie Zahlen eingeben, die noch nicht einmal im Datensatz enthalten waren – Das neuronale Netzwerk muss sie korrekt identifizieren.
Nachfolgend finden Sie den vollständigen Code des Klassifikators mit einem Datensatzgenerator für Trainings- und Eingabedaten:

import tensorflowImport itertoolsImport Zufälligvon Zeit Import ZeitKlasse ClassifiedNumber:__number = 0__classifiedAs = 3def __init__(selbst, Zahl):self.__number =Nummerif Zahl == 0:self.__classifiedAs = 0 # Nullelif Zahl > 0:self.__classifiedAs = 1 # positivelif Zahl < 0:self.__classifiedAs = 2 # negativdef number(selbst):return self.__Nummerdef classifiedAs(selbst):return self.__classifiedAsdef classifiedAsString(classifiedAs):if klassifiziert als == 0:Zurück "Null"elif klassifiziert als == 1:Zurück "Positiv"elif klassifiziert als == 2:Zurück "Negativ"def trainDatasetFunction():trainNumbers = []trainNumberLabels = []für i im Bereich(-1000, 1001):Zahl = ClassifiedNumber(i)trainNumbers.append(number.number())trainNumberLabels.append(number.classifiedAs())return ( {"number" : trainNumbers } , trainNumberLabels)def inputDatasetFunction():global randomSeedrandom.seed(randomSeed) # um das gleiche Ergebnis zu erhaltenZahlen = []für i im range(0, 4):Zahlen.append(random.randint(-9999999, 9999999))Zurück {"number" : Zahlen }def main():print("TensorFlow Positiv-Negativ-Null-Zahlenklassifikatortest von demensdeum 2017 (demensdeum@gmail. com)")maximalClassesCount = len(set< /span>(trainDatasetFunction()[1])) + 1numberFeature = tensorflow.feature_column. numeric_column("number")Klassifikator = tensorflow.estimator. DNNClassifier(feature_columns = [numberFeature], versteckte_Einheiten = [10, 20, 10], n_classes = maximaleClassesCount)Generator = Klassifikator.train(input_fn = trainDatasetFunction, Schritte = 1000).predict(input_fn =  inputDatasetFunction)inputDataset = inputDatasetFunction()Ergebnisse = list(itertools. islice(generator, len(inputDatasetFunction()["number"])))i = 0für Ergebnis in Ergebnisse:print("number: %d klassifiziert als %s" % (inputDataset["number"][i], klassifiziertAsString(result["class_ids"][0 ])))i += 1randomSeed = time()hauptsächlich()

Alles beginnt mit der main()-Methode. Wir legen die numerische Spalte fest, mit der der Klassifikator arbeiten soll – tensorflow.feature_column.numeric_column(“number”) Als nächstes werden die Klassifikatorparameter festgelegt. Es ist sinnlos, die aktuellen Initialisierungsargumente zu beschreiben, da sich die API täglich ändert, und Sie sollten sich unbedingt die Dokumentation für die installierte Version von TensorFlow ansehen und sich nicht auf veraltete Handbücher verlassen.

Als nächstes wird das Training gestartet, das eine Funktion angibt, die einen Datensatz mit Zahlen von -1000 bis 1000 zurückgibt (trainDatasetFunction), mit der korrekten Klassifizierung dieser Zahlen basierend auf positiv, negativ oder Null. Als nächstes übermitteln wir als Eingabe Zahlen, die nicht im Trainingsdatensatz enthalten waren – zufällig von -9999999 bis 9999999 (inputDatasetFunction), um sie zu klassifizieren.

Schließlich starten wir Iterationen basierend auf der Anzahl der Eingabedaten (itertools.islice), drucken das Ergebnis aus, führen es aus und lassen uns überraschen:

number: 4063470 als positiv klassifiziertNummer: 6006715 als positiv eingestuftNummer: -5367127 als negativ eingestuftNummer: -7834276 als negativ eingestuft

iT’S LEBEND

Um ehrlich zu sein, bin ich immer noch ein wenig überrascht, dass der Klassifikator sogar die Zahlen *versteht*, die ich ihm nicht beigebracht habe. Ich hoffe, dass ich das Thema maschinelles Lernen in Zukunft besser verstehen werde und es weitere Tutorials geben wird.

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

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

Bitcoin brechen

Dieser Hinweis ist kein Aufruf zum Handeln; ich werde hier die schwachen und potenziell gefährlichen Aspekte der Bitcoin- und Blockchain-Technologie beschreiben.

Gefährdetes Zentrum

Das Funktionsprinzip von Bitcoin und Blockchain besteht darin, eine gemeinsame Datenbank zu speichern und zu ändern, von der jeder Netzwerkteilnehmer eine vollständige Kopie speichert. Das System sieht dezentral aus, weil… Es gibt keine einzelne Organisation/Server, auf der die Datenbank gespeichert ist. Außerdem wird die Dezentralisierung als Hauptvorteil der Blockchain dargestellt; sie garantiert, dass Ihren Bitcoins nichts ohne Ihr Wissen passiert.


Das Block-Pest-Prinzip von Elkin

Damit die Blockchain funktioniert, muss sichergestellt werden, dass jeder Benutzer die neueste Kopie der Blockchain-Datenbank herunterlädt und nach bestimmten Regeln damit arbeitet. Zu diesen Regeln gehört die Umsetzung des Bitcoin-Mining-Prinzips, bei dem ein Prozentsatz jeder Transaktion nach Bestätigung (Transaktionsgebühr) des Geldtransfers von einer Wallet zur anderen erhalten wird. Der Benutzer kann nicht 1.000.000 Bitcoins für sich ziehen und damit etwas kaufen, weil… Für andere Benutzer bleibt der Geldbetrag auf seinem Konto unverändert. Ausgeschlossen ist auch die Möglichkeit, Gelder nur innerhalb der eigenen Datenbank von der Wallet einer anderen Person abzuheben, weil Diese Änderung wird nicht auf andere Bitcoin-Benutzer übertragen und ignoriert.
Die Schwachstelle der aktuellen Implementierung besteht darin, dass sich das Bitcoin-Wallet auf dem Server github befindet blockiert Werbeslogans zur Dezentralisierung vollständig. Kein Wallet-Download von einem einzigen Zentrum – Auf der Website des Entwicklers ist es unmöglich, mit Bitcoin zu arbeiten, das heißt, die Entwickler haben jederzeit die vollständige Kontrolle über das Netzwerk. Somit ist die Blockchain-Technologie selbst dezentral, aber der Client für die Arbeit mit dem Netzwerk wird von einem einzigen Zentrum.
Angriffsszenario – Nehmen wir an, dem Wallet wurde ein Code hinzugefügt, um alle Gelder abzuheben und auf das Konto Dritter auszuzahlen. Danach verliert jeder Benutzer der neuesten Version des Wallets automatisch alle Bitcoins (ohne Möglichkeit der Wiederherstellung). Ich bezweifle, dass viele Wallet-Besitzer es überprüfen und aus dem Quellcode erstellen, sodass die Folgen eines solchen Angriffs die meisten Benutzer betreffen werden.

Mehrheit entscheidet

Blockchain ist ein dezentrales P2P-Netzwerk; alle Transaktionen werden von den Benutzern selbst automatisch bestätigt. Angriffsszenario – Es ist notwendig, 51 % des Netzwerks zu erlangen, um Bestätigungen der restlichen 49 % zu ignorieren, woraufhin der Angreifer die volle Kontrolle über Bitcoin/Blockchain erlangt. Dies kann durch die Verbindung von Rechenleistung erreicht werden, die sich mit dem Rest überschneidet. Dieses Angriffsszenario ist als 51 %-Angriff bekannt.

Erraten Sie mich, wenn Sie können

Wenn Sie das Wallet zum ersten Mal starten, generiert der Computer ein Paar – privaten und öffentlichen Schlüssel, um den korrekten Betrieb sicherzustellen. Die Einzigartigkeit dieser Schlüssel ist extrem hoch, es besteht jedoch die Möglichkeit, Schlüssel mithilfe des Codeworts – das sogenannte „Brain Wallet“. Eine Person speichert Schlüssel in ihrem Kopf; sie muss die Datei wallet.dat nicht sichern, weil Mit diesem Codewort können die Schlüssel jederzeit neu generiert werden. Angriffsszenario – Der Angreifer wählt oder lernt das Codewort, generiert ein privates-öffentliches Schlüsselpaar und erlangt die Kontrolle über die Wallet.

Einfach kopieren

Das private-öffentliche Schlüsselpaar ist in der Datei wallet.dat enthalten. Jede Software, die Zugriff auf diese Datei hat – hat Zugriff auf eine Bitcoin-Wallet. Der Schutz vor einem solchen Angriff besteht in der Hinzufügung eines Codeworts, das sich der Benutzer merken und bei allen Transaktionen mit dem Wallet eingeben muss. Nach dem Hinzufügen des Codeworts benötigt der Angreifer wallet.dat und das Codewort, um die volle Kontrolle zu erlangen.
Es ist auch erwähnenswert, dass bei der Eingabe eines Codeworts dieses im Speicher des Computers gespeichert wird. Daher können alle Hardware- und/oder Software-Schwachstellen, die das Auslesen des Speichers *anderer* ermöglichen, dazu führen, dass Virensoftware dieses Codewort lesen kann.

Systemfehler

Das Hacken der Verschlüsselungsalgorithmen von Bitcoin führt sofort zu dessen Tod. Nehmen wir an, bei der Implementierung der Algorithmen wird ein Fehler gemacht, und der Angreifer, der ihn findet, erlangt entweder die vollständige oder teilweise Kontrolle über die Blockchain. Außerdem sind die in Bitcoin verwendeten Verschlüsselungsalgorithmen nicht vor Hackerangriffen zukünftiger Quantencomputer geschützt, ihr Aussehen und ihre Implementierung von Quantenalgorithmen – wird der aktuellen Implementierung von Bitcoin ein Ende setzen. Dies kann jedoch durch den Wechsel zu Post-Quanten-Verschlüsselungsalgorithmen gelöst werden.

Nixenv Linux-Konsolendienstprogramme für Windows

Ich habe meine eigene Alternative zu MSYS zusammengestellt. Dieses Set enthält die Dienstprogramme coretools + git + cmake + make + fügt msvs msbuild zur Umgebungsvariablen PATH hinzu. Diese Reihe von Anwendungen ist für Entwickler erforderlich, die mit der Entwicklung auf der Linux-Plattform vertraut sind und eine Anwendung für Windows über die Befehlszeile mit Microsoft Visual Studio erstellen müssen. Herunterladen:

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

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

Installieren, die Pfade in der Datei nixenv.bat ändern und ausführen.

Flammenstahl-Streitaxt

Ab heute beginne ich mit der Entwicklung eines Editors für das Gaming-Framework – Flame Steel Battle Axe.

Mit dem Editor können Sie Szenen für das Spiel-Framework Flame Steel Game Toolkit bearbeiten.
Ich habe mich für die relativ neue Java-basierte Kotlin-Sprache entschieden, um sie unter Kampfbedingungen zu testen.

Sie können den Vorgang im Repository verfolgen:
https://github.com/demensdeum/FlameSteelBattleAxe

WebGL + SDL + Emscripten

Am Ende habe ich Mika mit SDL 1 und Emscripten auf WebGL portiert.

Als nächstes beschreibe ich, was im Code geändert werden musste, damit der Build in JavaScript erfolgreich abgeschlossen werden konnte.

  1. Verwenden Sie SDL 1 anstelle von SDL 2. Im Moment gibt es einen SDL 2-Port für Emscripten, aber ich fand es angemessener, den in Emscripten integrierten SDL 1 zu verwenden. Der Kontext wird nicht im Fenster initialisiert, sondern mithilfe von SDL_SetVideoMode und dem SDL_OPENGL-Flag. Der Puffer wird mit dem Befehl SDL_GL_SwapBuffers()

    2. gezeichnet

  2. Aufgrund der Art und Weise, wie JavaScript Schleifen durchführt – Das Rendering wird in einer separaten Funktion platziert und der regelmäßige Aufruf erfolgt über die Funktion emscripten_set_main_loop
  3. Die Montage muss ebenfalls mit dem Schlüssel “-s FULL_ES2=1“

    4. erfolgen

  4. Ich musste die Assimp-Bibliothek aufgeben, das Modell aus dem Dateisystem laden und die Textur von der Festplatte laden. Alle notwendigen Puffer wurden auf die Desktop-Version geladen und zur Assemblierung mit emscripten.

    5. in die C-Header-Datei eingefügt

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

Artikel:
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

Modell:
https://sketchfab.com/models/7310aaeb8370428e966bdcff414273e7