In 2019’s State of JS over 30 frameworks were analyzed. This means that a large population has devoted time and energy into learning one of these frameworks while most-likely dismissing others that could be a better fit for their particular problem.

New issues arise and frameworks are created to address them. FrameQuarks are a vital part of development (especiialy in the Front End), and they are not going anywhere so we should embrace them.

However, the amount of overhead it takes to learn and analyze each framework would cause development to come to a standstill if you were to try to do so for any given project. Not to mention projects that have already begun.

Unless specifially created to do so, frameworks rarely work hand-in-hand with one another. While this may help validate one framework over another for specific use cases, it could the overall product of an application.

Imagine a development process where:

• You did not have to choose the framework before you began the project
• You could choose the best framework for the project at any point during development
• You could even export to mulitple frameworks
  • Run performance checks on each
  • Then decide which to push to production!

Pretty cool huh?
But we can take that one step further!

Imagine a development process where:

• A framework is never specified
• Each framework’s efficiencies have been analyzed
• Each framework automagically compiles the parts of your application that it can render / parse the fastest or most accurate
• Multiple frameworks work cohesively in your application with no additional effort on you as a developer*

^{* - everything could work ”out-of-the-box“, but is also 100% configurable if desired}

, when utilizing Concept Driven Development all of the following are supported:

• At any time during (or after) development you can specify your platform(s)
  • IPFS and GraphQL
  • PostgreSQL and Node
  • Web3 and SparQL
  • etc…
• If you’re not sure what you need, let our application decide, perhaps a Gatsby JAM stack will be suggested.

Any project created at DownQuark will be fully open sourced, and will attempt to use only open sourced material from third parties. DownQuark will strive to keep all repositories populated with the most up-to-date code available. And all comments and (constructive) critisisms and critiques will be welcome.

Questions and comments may not be answered right away, but will be answered as soon as possible. If you think it’s been too long then please re-send it. Or try getting in touch through another channel.

Phew… With all of that out of the way, if you’re still with us, why don’t you take a look at how we plan on accomplishing this.

To help prevent a TLDR; it is recommended to read the Envisioned Result scenario from the Mission Statement above first. I will be releasing the notes and stages for this project at its associated github repository.

There are numerous stages planned to bring this to its full potential, and I have a feeling that many of those will change as development begins and concludes for the steps that come before it.

In addition to the github repository:A kanban board will be shared on Taiga.
_{Both subject to change.}

As with the above I will be releasing the notes and stages for this project at its associated github repository.

The numerous stages will be mentioned there before hand to help gain a better understanding of how everything is to be integrated. But again, there are many unforeseen changes that are fully expected to come into play.

We will take a new approach to an IDE’s role in development, utilizing it in a way that allows the correct rendering of:

• code that is non-standard, almost without syntax
• competing frameworks
• high level functional programming
• most things in-between

There will be MUCH more information about this build as we proceed and the roadmap and kanban will most likely be more useful with this project than the FrameQuark. Because while the FrameQuark is the skeleton of the idea behind Concept Driven Development, this IDE integration is the brain.
Please browse the links below (as well as those from the FrameQuark above) to gain a better understanding of how the two projects will interact.

What appears to be another standalone desktop markdown note taking / code organizing app is deceiving. Let’s be honest:

• If you have have long prose or need to take notes about something outside of the computerized creative fields you will be hard pressed to find a better solution that Boostnote
• If you need to keep reusable pieces of code handy then you wil be better off using a product such as Renfei.org’s snippets-lab or OKatBest’sBoop
• And to see what happens when you run that code, a more intensive product like coderunnerapp will yield much better results

Unlike all of the above applications, ConceptIt is meant to evolve alongside your project.
While assisting in any and all aspects of Ideation this will keep all project notes relevant and available at a glance.
When pre-planning it acts will help organize all notes hastily created during brainstomring sessions, unfinished stream of consiousness thoughts, or anything else in disarray.
Add (or import from your current workflow) any mind-maps, mood boards, style guides, and other creatives.
- watch as all relevant colors, fonts, logos, etc update to the most recent entries (warning of ay conflicts) as you do nothign but continue doing your normal planning and design routine.

As development begins, a quick sync of the public content and the developer has all the notees organized into a codebase ready to be integrated.
- A prepopulated style guide for example
As development proceeds any questions can be entered into the developer’s ConceptIt App, any relevant information flagged, one or more people specified, and a notification sent.
- All people notified receive the question along with all flagged information at a glance. No time wasted trying to understand the question.
- The questioned answered, the developer make the update, and all synced ConceptIt Apps reflect the change

One more aspect of this. Developers have their own scratch notes and snippets.
And this application allows those to be expressed as the develper desires.
After the project goes live the developer has an idea for a loading animation. So he creaets a markdown code block with the language specified and adds a flag that it should be run as code.
- Anyone that views that section sees not only the markdown code block, but also the rendered/returned output from the snippet.
(more features will be added as developemt continues)

The final aspect that makes this application unique is what happens when design is approved and the developer creates a new project.
ALL information created in the planning phase is delivered to the IDE CoDEQ and applied to the empty application.
- Everything from styles to routes, from javascript methods to page content, is written to the project’s initial codebase awaiting further updates.
- (at this point CoDEQ treats the framework as the Single Source of Truth and will only make updates from the framework to the ConceptIt App)

An IDE that allows you to write the following:
First Name form field with a disabled gray button that becomes enabled and blue when there is at least one letter entered.
Will render the correct code to deisplay the elements and functionality described.

In addition to creating the end result the application will work backwards, deciphering where each piece of the given explanation would belong within the Atomic Design Pattern.
Along the way it compares values to previously defined variables to create or reuse consise, consistent Design Tokens.

When the organization of the rendered components has been solidified a Style Guide with custom GUI will be available allowing for additional tweaks or updates to be made within a bespoke IDE

An open source snippet manager utilizing javascript's prototypical inheritance that allows immediate integration into projects.

• Create a snippet that modifies a string
  • Require and use the snippet immediately
  • 'MySring'.mySnippetFunction()
• Share your favorite snippets by making a Pull Request and see them in the next version of this package!

Helping ensure consistency a set of rules will automatically validate the format of the string created when: committing code, creating or handling Pull Requests, or cutting new branches.

More information: coming soon

Continuing where NPM leaves off

Outside of an agency or development shop this may not result in an issue. If you are in a position where you rely on many node packages then the amount of storage occupied can get out of hand pretty fast.

The above code there were hundreds of `node_modules` folders returned. Taking up 5.6GB of memory.
NPM does a great job managing and distributing node packages, but I want to handle them differently when they are installed locally.

In a nutshell this will keep track of what projects use what packages from npm. It will then compile them into a centralized location and remove any redundancies while versioning correct updates as needed.

Note. This may help with the analytics: n³

More information: coming soon

Fraudulent Data that is auto-mocked whithin the CoDEQ.
   More information: coming soon

The CoDEQ will have the ability to create and define the backend CMS mappings as you write the frontend code…
   More information: coming soon

The CoDEQ will monitor the FrameQuark Use the template from frontendchecklist.io and automatically keep the items in sync as development proceeds.

Coming Soon

Preparing submission for:

• Conceptually driven AI & Game Engine development
• Free and Open Source Software builds of applications that currently have no “Free Tier”