Inhaltsverzeichnis











—-

Python related

I want to learn

Sorry, C++ im Backend ist definitiv das falsche Werkzeug. Keine ordentliche ORM-schicht die an Hibernate rankommt, kein Tooling für Microservices, nichts, was mit einer Service-Bus-Kommunikation vergleichbar wäre.
PHP fass ich auch nicht freiwillig an. Aber mittlerweile gibt es besseres im Backend-Bereich.

Inspiring

namespace

Wenn man in der .cpp 

namespace XSD {
namespace Core {
 
void bla( double d );
 
}}

ist bla entweder im Header als existent im Namespace XSD::Core oder es ist eine Funktion, die eine andere Funktoin als die im Header ( bla(int) ), also eine zusätzliche Funktion. Das gibt einen LInkerfehler. 

void XSD::Core::bla( double d);

führt zu einem COmpilerfehler.

static bla( double d ) führt zu einer Funktion, die dem Linker nicht bekannt ist.

Hier stellt sich die Frage, ob man eine Funktion ohne Static oder klaren Namespace überhaupt erlaubt ist.

PaketManager für C++

Buildsystem

Rexx / Microservices

Watch

Vergleiche

Formate / WebAssembly

C# Future

Compiler-Architecture

Mars Programming Language

Assembler

Benchmarks

Makefiles

Programmierprinzipien

Scriptgenerierung

BLogs

Andere Software

Libraries

Mantras

Stroustrup

Grundlegende Fragen

Point-Free Programming

Generisch

Kann es ein Konzept geben, das grundsätzlich Generisch ist? Also über die Idee „Container“ hinausgeht. Zum Beispiel GUI + Text + Syntax-Highlighting ⇒ Texteditor?

Mehrdimensionale Ableitungen

Kann es ein Konzept geben, dass mehrdimensionale Ableitungen erlaubt.

Wiki-String leitet von String ab. File-String leitet von String ab. (kann auf Festplatte lesen/schreiben) Replace-String leitet von String ab. (ersetzt Variablen innerhalb des Strings)

Gibt es nun eine Möglichkeit, diese wieder zusammen zu führen ohne Interfaces zu nutzen? So dass alle Erweiterungen zusammengepackt werden, aber nicht die String-Klasse mehrfach auftaucht und auch nicht virtuell abgeleitet wird. Quasi eine Template-Ableitung.

Vergleiche XSD::Data::Primitive

Speichern und Laden von Stacks

Ich würde gerne ein System-Kommando haben, was ein Stackabbild einer Funktion speichert, also die Parameter rekonstruierbar macht, so dass diese Funktion mit den gleichen Parametern wieder gerufen werden kann. Das bedeutet ggfs. alle verpointerten Elemente wieder herzustellen und sich Gedanken um eine Versionskontrolle/Hash-Werte des Strukturaufbaus beim Speichern und wieder laden zu machen - im Worst-Case muss der komplette Strukturaufbau mit in das Abbild.

Sinn der Sache ist Tests anlegen zu können.

Hierzu könnte innerhalb von Tests ein Debug-Construct gerufen werden, der die Variablen nennt und belegt. 

Segment contains
{
  isOn is method( on is Point ) :=
  {
    debug(0)        test.writeTest( "testSegment"+on.x$+"_"+on.y$ ) >> io("file://c:\temp\mytests.g" ); // beim ersten Mal
    debug(500)      test.writeTest( "testSegment"+on.x$+"_"+on.y$ ) >> io("file://c:\temp\mytests.g" ); // beim 500. Mal
    debug(on.x ==5) test.writeTest( "testSegment"+on.x$+"_"+on.y$ ) >> io("file://c:\temp\mytests.g" ); // wenn x == 5 ist.
    
    return ...
  }
};


// test
testSegment5_0 is test :=
{
  s is debug Segment( source = debug Point( debug X(0.0), debug Y(0.0) )
                      target = debug Point( debug X(10.0), debug Y(0.0) ) );
  on debug construct Point( debug construct(5,0), debug construct(0.0) );
  
  expectedValue = // Put Expection here
  
  return s.isOn( on ) = expectedValue;
}

Ausbildung

Social Media

Stack