Sjoemeleboems weblog

Can't stop (programming)

Ik draaf de laatste tijd een beetje door. Maar laten we het positief Zien: Ik barst van de motivatie en ideeën. Ik ben flink aan de weg aan het timmeren met mijn framework. Ik verzin steeds meer, en kan het amper bijhouden. Ik moet dus nog wel tijd vinden om alles af te bouwen...

Het is lastig om een definitie of korte samenvatting te geven van dit framework, wat ik op dit moment ook nog maar 'Yet Another Framework' noem. Maar misschien is het beste om te zeggen wat mijn doel is: Ik wil herhalende en niet-uitwisselbare code voorkomen. Ik wil niet iedere keer hetzelfde bouwen, en ik wil dingen die ik bouw opnieuw kunnen inzetten. En dit allemaal schaalbaar, veilig enzovoorts.

Eén van de pijlers van mijn framework is Component Based Design. Functionaliteit stop je in een component, en elk component heeft ook maar een beperkte set rollen en taken. Dit verhoogt de (kans op) uitwisselbaarheid.

Verder is modelleren heel belangrijk. Ik vind, dat je zowel je proces als je datastructuren moet kunnen modelleren, en je moet dit ook nog run-time kunnen doen. Hiervoor heb ik veel meta-informatie nodig, maar dat is geen probleem.

Ten slotte is ook uitbreidbaarheid belangrijk. Alle plekken waar je verwacht dat functionaliteit aangepast of uitgebreid moet kunnen worden, moet je in componenten stoppen, zodat je dit kunt vervangen.

En dan nog het amateuristische aspect: Ik ben nu zelf eens de opdrachtgever, en ga niet bezuinigen op de tijd/opleverdatum. Alles moet goed, of zelfs meer dan goed zijn. Natuurlijk, ik kan consessies doen of zaken vooruitschuiven, maar dit doe ik dan het liefst alleen in componenten. zodat je kunt zeggen: Als je dat wilt, dan moet je dit component vervangen. Het antwoord "dit is niet mogelijk" wil ik niet geven.

Wat me hele leuke inzichten geeft, is het modelleren van mijn framework in Excel. Ik genereer alle code met één druk op de knop in Excel, en dit hoef ik alleen nog maar door de C# compiler te halen.

Wat het uiteindelijk zou moeten opleveren, is een framework waarop je gemakkelijk applicaties kunt bouwen. Dit moet schaalbaar, veilig, robuust en uitbreidbaar zijn.

Hopelijk kom ik binnen een paar maanden met een compleet werkend geheel, van back-end tot GUI. Tot die tijd is het nog een beetje rommelen met een testproject. Maar je kunt al aardig wat!

Happy coding! ;-)

Excel code generation (continued)

Ik gebruik nu al een tijdje mijn Excel Code Generator voor het genereren van mijn Framework. Dit werkt al aardig, maar ik miste nog wat mogelijkheden.

Wat ik nu heb toegevoegd, is dat je in de code weer placeholders kunt opnemen waar templates in geplakt worden. Deze worden opgebouwd tijdens het verwerken van het model. Zo kun je waarden zetten van alle members. Verder heb ik de code wat beter beheersbaar gemaakt. Zo werk ik nog wel met kolomnummers in plaats van namen, maar de nummers zijn nu als constanten gedefinieerd. En verder heeft elk soort sheet (delegate en class) nu een eigen methode, die vanuit de hoofdmethode aangeroepen wordt. Zo is de hoofdroutine een stuk korter geworden, en kun je daar nu ook gemakkelijk je eigen extensies in schrijven.

Ik hoop dat ik het framework van voor naar achter af krijg. Het compileert wel, maar het is behoorlijk groot. Een echt werkend geheel is het nu dus nog niet...

Happy coding! ;-)

Two-way code synchronization

Ik heb het voor elkaar gekregen om behalve van model naar code ook de wijzigingen in code weer op te nemen in het model, zodat ik dezelfde files opnieuw kan genereren zonder code kwijt te raken.

Misschien denk je nu: waarom gebruik je dan geen partial classes? Maar in mijn model heb ik alleen de structuur van de classes staan, en niet de code die erin zit. Ja, ik heb verwijzingen naar bestanden per method en constructor, en die bestanden moeten dus bijgewerkt worden, als je opnieuw genereert.

Wat ik nu kan, is in eerst de structuur van de classes genereren, en in Visual Studio.Net code schrijven voor elke class. Vervolgens hoef ik in mijn model alleen nog maar bestandsnamen in te typen bij elke method, en vervolgens zou ik het model opnieuw kunnen genereren zonder dat ik de getypte code kwijt ben.

De truuk die ik hierbij gebruik, is dat ik bij elke methode die ik met de hand tik in Visual Studio.Net regels commentaar moet opnemen, zodat ik dit weer kan parsen in de code generator. Dit doe ik als volgt:

//begin #bestand.cs#

DoeIets();

//end #bestand.cs#

Alles wat hiertussen staat, is dus de code van bestand.cs.

Happy coding! ;-)

Framework voor het bouwen van een framework

Hoe compileer je een compiler? Dat vind ik een interessante vraag. Een vergelijkbare situatie heb ik nu zelf: hoe maak ik een framework voor (het maken van) mijn framework?

Mijn framework begint steeds groter te worden. Ik had besloten om helemaal opnieuw te beginnen, om bij elk detail stil te staan. De totale architectuur (classes, methoden, attributen) wil ik eerst modelleren. Dus ik wil een stap terug doen: niet bouwen, maar terug naar de tekentafel.

Aldus ben ik begonnen met het modelleren van mijn framework. Het heeft inmiddels meerdere doelen:
-Entity framework
-Code generatie op basis van templates
-Basis voor een modulair uitbreidbaar systeem op zowel business logica als presentatie (GUI) niveau
-Mogelijkheid voor zaken als dynamische compilatie, flexibele client/server architectuur, macro's opnemen en afspelen, enzovoort.

Nu kan ik hopelijk gemakkelijk nieuwe functionaliteit modelleren zonder al teveel moeite. Vanuit het model genereer ik C# code, die ik weer compileer tot een applicatie waarin je kunt modelleren :)

Het zal mij benieuwen, of ik het voor elkaar krijg om dit werkend te krijgen. In het begin zal het moeilijk zijn, omdat ik op dit moment nog met veel compiler errors zit. Dit wordt echt een uitdaging!

Happy coding! ;-)

Macro functionaliteit ingebouwd

Ik heb een robuuste, generieke en uitbreidbare oplossing voor macro's in mijn GDP framework gebouwd. Het scherm heb ik redelijk van Office afgekeken, hoewel die van mij een stuk simpeler is. Aan de linker kant zie je alle macro's, aan de rechter kant de geselecteerde macro en daaronder informatie over de uitvoer. Vanuit de macro kun je hier ook naartoe schrijven.

Grotendeels bestaat de oplossing uit een aantal onderdelen:
*Een MacroHostExtension, die macro's kan opnemen en afspelen. De standaard implementatie ondersteunt C#.
*Een MacroRepositoryExtension, die macro's kan opslaan. De standaard implementatie ondersteunt in-memory en opslag op file system.
*Via de Callback moet je vanuit de GUI, als Record Macro actief is, doorgeven welke macro stappen toegevoegd moeten worden.

Het framework ondersteunt ook custom events. Zo kun je een opdracht (actie) en argumenten meegeven. Verder ga ik alle standaard acties die ik kan bedenken vanuit de GUI toevoegen als constante, zodat je daar geen typefouten in maakt.

Ik heb de eerste versie inmiddels werkend. Je kunt een opname starten, de GUI een actie laten doorgeven, en dit wordt vertaald naar C#. Je kunt deze macro bewerken, afspelen, hernoemen en verwijderen.

Naast C# ga ik nog PowerShell ondersteunen, maar dit ga ik in een custom implementatie doen. Ik hoef dan alleen wat methoden te overriden.

Happy coding! ;-)