This post was published 2 years 7 months 13 days ago and as such probably does not reflect my current opinions, knowledge or ability.How can a non-strict programming language be designed to aid the generation of organic models?
After much thought, even considering changing my topic entirely, I’ve managed to focus my initial idea into a project which should be feasible within the (very limited) time available. As with last week, I’ve been provided some questions to help progress with the project, this time considering my research question.
First of all though, here’s an overview of my idea which has been refined greatly since I last discussed it. My previous suggestion was still very broad, so I tried to narrow it down in three main ways:
- Limiting the type of geometry to be produced.
- Choosing a focal point for the project: compiler design, language design or geometry creation.
- Selecting a specific feature of language design to investigate.
After more research and some pen-and-paper attempts at how the language and geometry might function, I decided that creating plant or tree models based on L-systems would be an area where the use of a scripting language could be particularly beneficial. When considering L-systems and fractals, the idea of an infinitely repeating shape or process comes to mind. Through designing a language which uses types of lazy evaluation, this concept of infinite repetition can be upheld even though only the minimal processing required to produce or render the geometry will actually be performed.
1. What is the focus of your project?
- Language design
- Evaluation strategies and non-strict evaluation
- Compiler design
- Procedural geometry
- L-systems, graftals and fractals
Practical aspects of the project will require investigation of all these elements to some extent, however the research focus should remain on language design and in particular how lazy evaluation relates to geometry creation.
2. What information do you need to find out about?
- I have identified several general sources to expand on my knowledge of compiler and language design. It will also be necessary to seek out resources which relate more specifically to this project.
- In terms of procedural geometry I will need to study the creation of organic (plant) models based on L-systems. Luckily, there is a wealth of information covering a range of topics in this area.
- Previous attempts at creating fractals and procedural models from scripts will need to be investigated in order to compare them to the solution I hope to produce.
- It will be necessary to look at existing non-strict languages and their design.
- Information regarding model file formats will have to be obtained if it is decided that the language should produce geometry directly rather than outputting functions for its creation.
3. What Experimental work do you need to perform?
The majority of practical work will involve designing a language and implementing a compiler for it. Alternatively, an existing non-strict language could be extended; however, this might well prove a more significant task than creating a new, but very limited, language.
A simple way of demonstrating the output of this should also be implemented, however this should be a minor consideration.
4. How will the information that you obtain allow you to answer the research question?
Currently, one of the most prominent issues with my research question is that it is mainly subjective. Although it should be easy to consider ways in which the solution does or does not add to the field of generation of procedural models, it would not produce numerical results which could be compared to existing options. I hope that demonstrating that the language created can successfully create plant models would suffice to answer the research question in its current form, however I would appreciate advice on how the question or project might be modified to provide a more objective comparison.
Hi Hazel, apologies for the late reply.
You mention you wanted refining to the question, it seems to be mostly fine, from re-reading it, I see what you intend to design and what it will be, in future, used to produce, the only part which I didn’t comprehend right away was an organic system, fractals and L-systems didn’t instantly spring to mind, though this is probably just nitpicking.
The overall project seems to be fine on scale, you have clear goals and a priority of what you aim to achieve; and what you want to achieve once you have these main systems up and running. Though concerning the possible lack of visual or statistical output, I would think many of us are unsure on how much would be overkill, or if what we have is enough, but with prioritisation of the implementation of the project, we simply get as much done as we have time for, as I understand it many of the previous years’ projects had a scope much larger in the documentation for what was produced, and I would imagine this is fine.
Hey Jack – thanks for the feedback. It isn’t late by any means.
In terms of the “Organic models” in my question I do see what you mean. I didn’t want to explicitly list L-Systems but currently the statement could be refering to something as broad as modelling cell behaviour or animal life. I’ll try to pin that down by either mentioning plant or fractal-based geometric models explicitly.
Thanks for your encouragement in the second paragraph. Hopefully by talking to an academic supervisor I can establish exactly what will provide a suitable solution to the reference question, and refine it as necessary.
Hey… just seen you have another post on this same topic…
On the issue of evaluation strategies, again you might find clojure interesting as though it is a strictly evaluated language, it makes extensive use of lazy sequences, to the point where almost all of clojures core sequence abstractions are lazy.
http://clojure.org/sequences
Ok… I really will stop telling you about clojure now! It’s clearly my new hammer!
Hey,
Variations in evaluation strategies within languages is something I’ve been looking at, since I’m focussing on the idea of how lazy evaluation might help produce certain structures rather than the difference it makes to working in a language across the board.
Although I can read and understand what the information on Clojure sequences is saying, I don’t think I can really comprehend the implications without playing with the language a little. So I’ll certainly try and set aside some time to do that.
Thanks again,
Hazel.