GB2510866A - Computer code editor - Google Patents

Abstract

A computer code editor comprises logic configured to: receive and edit configuration information, where the configuration information defines any one or more of functional requirements, structure, and behaviour of a required application; and display the configuration information in a nested format. A code generator, such as a compiler, may generate code, such as source code or executable code, to form the required application from the configuration information. The configuration information may comprise elements and sub-elements, and these may be displayed at increasing indentation levels, and may be grouped together. The logic may highlight different nested levels, and may highlight elements and sub-elements having the same type in the same way. The required application may be a web application.

Description

tM:;: INTELLECTUAL S... * PROPERTY OFFICE Application No. 0B1302693.5 RTM Date:11 Scptcnibcr 2013 The following terms are registered trade marks and should be read as such wherever they occur in this document: Osx Linux

UNIX

Intellectual Properly Office is an operaling name of Ihe Patent Office www.ipo.gov.uk

COMPUTER CODE EDITOR

Field of the Invention

The present invention reiates to a computer code editor and method and in particular to an editor and method for producing and editing web appiication code.

Background of the Invention

Computer application code generators and in particular web application code generators provide a graphical user interface to capture and record configurations from a computer programmer. Such graphical user interfaces may be based on graphical data lists, forms, menu items, visual diagrams and other graphical forms.

Code generators may alsc provide a property box for allowing programmers to view and change element and settings of each configuration element forming the configurations provided by the computer programmer. Where an element contains other elements, then a separate property box may be used for each sub-element.

However, using such systems makes it difficult to provide a computer programmer with a complete view of the configurations or the relationships between particular elements and sub-elements.

Integrated development environments may be used to transform a higher level source code, authored by a computer programmer, into a lower level source code or target code in order to make the source code executable or ready for further compilation into yet lower level code.

Typically, a computer programmer will write source code until they are satisfied that it is complete and ready for testing or execution. The ccmputer programmer may then invoke a compilation command to transform the source code, as desired.

Computer programmers may wish to view the target or compiled code after compilation or transformation.

Therefore, this requires complete compilation of all provided source code before the target code is available for viewing. Whilst full compilation results in a fully executable or complete target code, this does require completion of the full source code. This is not always convenient for the computer programmer.

High level computer programming languages may be easier to work with and more intuitive, but are generally less powerful than lower level languages, which are more difficult to understand and work on by a computer programmer.

Furthermore, each individual programming language will have its own syntax (grammar) and a set of concepts (semantics) . These must be strictly followed in order to provide operational computer programs. Each syntax, concept, semantic and rule must be accurately adhered to for each individual language.

Many factors may be invclved in choosing a particular programming language for a particular computer program, application or use. This may also depend on the knowledge of the computer programmer and their particular skills.

Even if it is decided that a particular application and its requirements would in general benefit from a particular programming language, there may be individual aspects or functions that would be more suited to a different computer programming language. Therefore a compromise is inevitable in choosing one programming language over another.

This compromise means that certain parts of the computer program may be less optimal than others or more difficult to produce than others.

Therefore, there is provided a computer program editor, generator and compiler that cvercome these drawbacks and problems.

Summary of the Invention

Against this background and in accordance with a first aspect there is provided a computer code editing tool or computer code editor comprising logic configured to: receive and edit configuration information, wherein the configuration information defines any one or more of: functional requirements, structure, and behaviour of a required application, and display the configuration information in a nested format. Therefore, this provides a single view of the configuration information. This also provides the configuration information in an easier to understand format.

Configuration information can therefore be added and maintained more accurately and more efficiently. A nested format may further comprise a hierarchical format. In a nested format, the configuration information may include one or more levels of information. Nesting may involve displaying the hierarohy of parts of the configuration at different levels. Configuration information may be grouped together. Nesting may be a self-similar or a recursive structure typically of different layers (e.g. a layered structure) . Items of configuration Information may enclose one or more other items of ccnfiguration Information. The tool may be implemented in software, hardware, executed on a terminal, computer or other interface.

Preferably, the configuration information may define any one or more of: functional requirements, structure, and behaviour of the required application.

Preferably, the computer code editormay further comprise a code generator configured to generate code to form the required application from the configuration Information. This provides the required computer code.

Preferably, the code editor may further comprise a complier. This allows the configuration Information to be incorporated into an application.

Preferably, the generated code is source code or executable code. The source code may be further edited or compIled. Executable code may for an application.

Optionally, the configuration information may comprise a plurality of elements and a plurality of sub-elements, wherein one or more sub-elements are associated with an element. This allows finer control of the configuration of an application.

Optionally, the logic may be further configured to display the nested format as the elements on a first indentation level and display the sub-elements on a second indentation level, wherein the second indentation level is further indented than the first indentation level.

Optionally, sub-elements associated with an element may be displayed directly following the element and grouped O together. This allows easier identification and editing.

Optionally, the logic may be further configured to display the configuration information in a plain text window. This further reduces complexity and aids interpretation and analysis of the information.

Preferably, the logic may be further configured to highlight different nested levels of the configuration information. This further aids analysis and editing.

Optionally, the logic may be further configured to highlight elements and sub-elements having the same type in the same way.

Preferably, the required application may be a web application. Other application may be required and used, configured or generated.

According to a second aspect, there is provided a method for assisting with the generation of computer code for a required application, the method comprising the steps of: receiving configuration information for the required application; and displaying the received configuration information in a nested format.

Preferably, the configuration information may define any one or more of: functional requirements, structure, and behaviour of the required application.

Preferably, the method may further comprise the step of generating code to form the required application from the configuration information.

Optionally, the configuration information may comprise a plurality of elements and a plurality of sub-elements, wherein one or more sub-elements are associated or related with an element.

Preferably, the configuration information is displayed in a single window.

According to a first illustrative example, there is provided computer programming tool comprising: a source code editor; a compiler for compiling the source code into compiled code, wherein the source code is at a higher programming level than the compiled code; and a display generator configured to display the source code and the compiled code such that portions of the compiled code are identifiable with corresponding portions of the source code. Therefore, a computer programmer can view target or compiled code next to its corresponding source code. This provides easier switching between the two levels of code. Development time may be reduced as the computer programmer does not need to write source code, compile all of the source code and then leave the source code to test, run or inspect the compiled or target code.

The tool may be implemented in software, hardware, executed on a terminal, computer or other interface.

Optionally, the display generator may be further configured to display the portions of the compiled code in line with the corresponding portions of the source code.

This may be inline on a display screen either substantially horizontally or substantially vertically (or other way) , for

example.

Preferably, the computer programming tool may further comprise a text editor for receiving or editing the source code. Other features may be included.

Optionally, the programming tool may further comprise logic or means to detect edits, additions or deletions to the source code. This may be by the computer programming making such changes though an interface with the programming tool.

Optionally, the compiler may be configured to compile the source code in response to any edits, additions or deletions to the source code detected by the logic. In other words, the alternations or additions made may trigger compilation of only the relevant portions where changes are detected, related sections or the complete code, for

example.

Preferably, the display generator may be further configured to display changes to the compiled code in response to any edits, additions or deietions to the source code detected by the logic.

Preferably, the computer programming tool may further comprise an input for receiving a request for compiling the source code. The input may be in the form or text from a keyboard or from a computer pointing device or other interface.

Preferably, the computer programming tool may further comprise logic configured to detect a selection of a portion of the source code and in response highlight a corresponding portion of the compiled code. Therefore, the computer programmer or developer may be assisted in identifying which portions of source code relate to specific portions of compiled code. This may also assist in learning the source code language, especially for individuals familiar with the compiled or target code. This may also assist is identifying, locating an fixing errors and bugs in the source code.

According to a second illustrative example there is provided an integrated development environment comprising the computer programming tool described above.

According to a third illustrative example, there is provided a method for displaying source code and compiled code comprising the steps of: receiving source code; compiling the received source code into compiled code; and displaying the source code and the compiled code such that portions of the compiled code are identifiable with corresponding portions of the source code.

Optionally, the method may further comprise the step of receiving a selection of a portion of the source code and in response highlight a corresponding portion of the compiled code.

According to a fourth illustrative example, there is provided a compiler comprising: logic configured to: receive computer code comprising code elements in two or more different computer languages; identify the computer language of each code element; and generate a code output for each code element dependent on its identified computer language. The compiler may be implemented in software, hardware, executed on a terminal, computer or other interface. Therefore, fragments or components of computer code from in one language may be injected into portions of computer code in another language.

This allows applications to be built without being restricted to a single language. It also allows the benefits of different computer languages to be realised and reduces compromises.

Preferably, the generated code output for one or more identified computer language is unchanged from the received code element. In other words, the base (or source) language may be compiled or transformed into a second language (target or compiled language) The input code may comprise fragments or portions that are already in the target -10 -language and so pass through the compiler or code generator unchanged.

Optionally, the computer language of each code element is identified from a text identifier in the computer code.

There may be other ways of identifying the language or format of each code element that do not involve textual tagging.

Optionally, the text identifier may be selected from the group consisting of: tag, prefix, suffix, wrapped text, comment text and mark-up tag.

Optionally, the two or more computer languages may be selected from the group consisting of C#, C, C++, ASP, and ASP.NET. Other languages may be used.

According to a fifth illustrative example, there is provided a method for compiling computer code comprising the steps of: receiving computer code comprising code elements in two or more different computer languages; identifying the computer language of each code element; and generating a code output for each code element depending on its identified computer language.

Preferably, the generated code output for one or more identified computer language may be unchanged from the received code element.

-11 -Optionally, indentifying the computer language may further comprise detecting text markers within the computer code associated with each computer language.

Optionally, each code element may have the identifying text marker written in the same computer language.

Optionally, the text markers may be constant values.

The methods described above may be implemented as a computer program comprising program instructions to operate a computer. The computer prcgram may be stored on a computer-readable medium.

The methods, computer programming tools and compiler may be implemented using programme instructions running on a suitable operating system (e.g. Window, OSX, Linux or UNIX) on a computer, computer system or other suitable hardware (e.g. x86 processor, hard drive, keyboard, mouse, display monitor and power supply) . Ihe computer system may be stand-alone or distributed over a local or wide area network, for example.

It should be noted that any feature described above may be used with any particular aspect, illustrative example or embodiment of the invention. For example, any two or more of the aspects or examples described above may be combined with each other. Any optional or preferable feature may be used with any one or more others.

For example, there may be provided a product or method that combines the computer ccde editor, compiler and computer code programming toci.

-12 -

Brief description of the Figures

The present invention may be put into practice in a number of ways and embodiments will now be desoribed by way of example only and with referenoe to the a000mpanying drawings, in which: Fig. 1 shows a schematic diagram of a display of a computer code editing tool, given byway of example only; Fig. 2 shows an example screen shot of the display of fig. 1;

Fig. 3 shows a schematic diagram of a prior art

computer programming tool; Fig. 4 shows a schematic diagram of a computer programming tool used to provide source code and its corresponding compiled code; Fig. 5 shows a schematic diagram of a further embodiment of a computer programming tool showing source code and its corresponding compiled code; Fig. 6 shows an example screen shot generated by the computer programming tool of fig. 5; and Fig. 7 shows a schematic diagram of a compiler given by way of an example only.

It should be noted that the figures are illustrated for simplicity and are not necessarily drawn to scale.

Detailed description of the preferred embodiments

Glossary: * "Web Application": A software program in the form of a web application that a Programmer intends to produce quickly using a Code Generatcr.

-13 - "Code Generator": A software utility or tool that may be used by a Programmer to quickly define the requirements of a Web Application in the form of higher level Configurations. The Code Generator may then generate the Target Code for such Web Application from the Configurations provided by the Programmer.

"Configurations": The information provided by a Programmer inside a Code Generator to define the requirements, structure and behaviour of a Web Application, so that the Code Generator may generate the Target Code from such information. The Configurations for each Web Application may consist of a number of Configuration Elements.

* "Configuration Element": An artefact that holds some information about the structure or behaviour of one or more aspects of a Web Application. Each element will usually contain a number of Element Settings. In addition each Element may be a container for other Configuration Elements (also contextually called Sub-Elements) * "Element Settings": A list of Keys and their Values for a Configuration Element. The keys may be pre-defined fields for each type of Configuration Element in a Code Generator, while the Values may be edited by a Programmer, typically in a Property Box.

* "Property Box": A prior art graphical window that displays the Element Settings of a Configuration Element and allows a Programmer to change the Values of such settings.

"Target Code": The computer code of a Web Application that is generated by a Code Generator from the Configurations provided by a Programmer.

Configurations User Interface: The software user interfaoe of the Code Generator provided to a Programmer to capture and record the Configurations.

-14 - "IDE" (also called an Integrated Development Environment or Language Workbench) : A computer software/tool that may he used by programmers to author and edit Source Code and compile them into Target Code.

"Source Code" (also called a Program) : The computer code or program written in a higher level computer language that is written by a programmer in order to define a software program. The source code may be authored or edited in an IDE and may be compiled into Target Code by a Compiler.

"Target Code" (also called "Destination Code" or "Compiled Code") : A lower level computer program that is the result of a Compilation. A Target Code is generated by a Compiler from a Source Code that is written by a Programmer.

"Compilation": The act ci generating a Target Code from a Source Code.

"Compiler": A utility or computer program that is used by or hosted in an IDE which performs Compilation to transform the Source Code written inside an IDE by a Programmer into a Target Code.

"Compilation Command": An action, trigger or command provided by an IDE to allow a Programmer to request a Compilation.

"Programmer" (also called Developer) : A real person that uses an IDE to write a Source Code to define a Program.

"Programming Language": An artificial language designed to communicate instructions to a computer.

"Source Language": The particular Programming Language in which the Source Code is written.

"Target Language": The particular Programming Language in which the Target Code is written.

-15 -In one implementation, there is provided a single user interface view for displaying and editing a hierarchy of configuration elements (in nested or recursive form) and their settings in a way to resemble text-editing. This may be particularly useful within a user interface for web application code generation tools.

Web application code generators may provide some form of a graphical user interface to capture and record configuration information frcm a computer programmer. Prior art user interfaces are typically based on graphical data lists, forms, menu items, visual diagrams or any other graphical form.

Code generators may provide a property box allowing the programmer to view and change element settings of each configuration element. In cases where an element contains other elements, a separate property box may be used for each sub-element.

According to one example implementation, there is provided a single view to display and capture the settings of multiple sub-elements in a hierarchy or nested format of elements.

In the present code generator and method, capturing the configurations from the programmer may consist of two components.

The first component may be an interface that resembles a text-based editor. Preferably, this user interface should not contain any borders, shadows and background colours so that user interface elements may show and capture configurations information from the programmer in a way that the end result resembles a text-based editing experience for the programmer.

The second component may be a single editing interface displaying a hierarchy of elements and sub-elements. Using -16 -this approach, a single user interface may be provided that shows and enables editing of the settings of multiple elements in a hierarchical, nested or recursive format and so avoiding the use of property boxes for each element and sub-element.

This provides a familiar "programming language" experience for the programmer that is using the code generator so that the configurations are viewed and edited in a user-interface that resembles text editors.

Figure 1 illustrates schematically a nested or hierarchical display format. Element 1 has a number of sub-elements (1.1, 1.2 and 1.3). Sub-element 1.3 itself has sub-elements 1.3.1 and 1.3.2. Whereas this would reguire six property boxes to define in prior art code generators, this is instead displayed textually and in a nested format in simplified form.

Figure 2 shows a screen shot of a nested format view of the configuration information. The different shaded text illustrates highlighting of similar types of data and also different levels within the hierarchy. Colours or other font changes may also be used to highlight these properties.

According to a first illustrative example, there is provided a method and computer programming tool for displaying compiled code at programming time within an integrated development environment (IDE) Displaying the compiled code next to the source code inside an IDE or software program editing tool allows the programmer to see generated target code from the associated or corresponding source code in real time.

Such a method may be implemented within software programming tools, environments, IDEs and source code authoring tools.

-17 -IDEs generally transform a higher level source code authored by a programmer into lower level target code in order to make the source program executable or ready for further compilation into yet lower level code for ultimate execution.

During a programming session, the programmer may write the source code until it is ready for testing or execution.

Then the developer may invoke a compilation command provided by the IDE.

Figure 3 illustrates schematically a prior art

programming tool 100 used to receive source code 20, compile it using a compiler 30 into target or compiled code 40.

If the programmer wants to see the generated target code 40, then the compilation command may be invoked and the programmer 10 then leaves the source code view to look at the target code 40. Existing IDEs are limited in this way as they cannot provide a mechanism for the programmer 10 to see the generated target code 40 easily next to the source code 20 or with easier switching between the two.

A schematic diagram of the improved computer programming tool 200 is shown in figure 4. This tool 200 displays the target code 40 along with the source code 20.

A compiler 30 generates the target code 40 from the source code 20.

This may be achieved by automatically invoking a compilation command upon every change to the source code 20 made by the programmer 10. The target code 40 may then be contextually picked so that it is directly generated as a result of the specific area of the source code 20 being written or edited by the programmer 10. These portions of source code 20 may then be compiled in real time.

-18 -Furthermore, the programmer 10 may be visually informed of the target code 40 that will be generated by the oompiler from their source code 20.

This provides an advantage to the programmer 10 by providing an early opportunity for identifying and fixing bugs.

As a result, the programmer 10 may have less need to go through a time-consuming seguential process of: * 1) Writing the source code 20 * 2) Compiling the source code 20 into target code * 3) Leaving the source code 20 to test, run or inspect the target code 40 tc find issues and bugs.

A further embodiment of the tool 200' Is illustrated schematically in figure 5. As a further enhancement, the programmer 10 may be able to select each specific area 25 of the source code 20 and see the resulting corresponding target code portion 45 affected or generated from the specific selected area of the source code 25. Both source code fragment 25 and its corresponding target or compiled code fragment 45 may be highlighted indicating the correlation.

This eases the process of learning the source code language for a programmer who may be more familiar with the target language 40. In addition this feature makes it easier for a programmer 10 to find and resolve bugs and issues in the source code 20.

Figure 6 shows a screen shot 300 of the display generated by the computer programming tool 200'.

The higher level code (e.g. M#) on the left side 310, has been compiled into the lower level code (CU on the right hand side 320. In this example, the source code segment 25 is highlighted with a box, as is the -19 -corresponding target code segment 45. The target code 40 and source code 30 do not necessary (but may) align completely on the screen due to the different amount of text required to render them.

According to a second illustrative example, there is provided support for target code 40 injection into a higher or different level programming language.

Higher level programming languages are generally less powerful than lower level languages, but they may be generally more produotive. Ibis creates a compromise and can limit the usefulness of higher level languages. This embodiment provides a way to bring the power and flexibility of lower level programming languages to the higher level ones.

Programming languages generally provide a syntax (grammar) and set of concepts (semantics) .Any source code written in a specific programming language will have to conform to the syntax and rules of that language, and will be limited to the concepts and semantics provided by that language.

Even though any source code 20 may ultimately be compiled into a target or compiled code 40 by a compiler 30, there is currently no way for the programmer 10 to inject fragments of code in to the language of the target code 40 (or other languages) into the source code 20.

The reason for this is that the language of the target code 40 may also have its own syntax, rules and concepts which may be either non-existing or conflicting with those of the source code language. Such conflict may make it impossible to correctly parse and compile the program in a predictable and consistent way.

-20 -Figure 7 illustrates schematically an example compiler 400 according to an embodiment. This makes it possible to write code (I.e. fragments or portions of code 410) In the language of the target code 40 (or other languages) right inside the source code 20.

This allows a programmer 10 to choose either language (or several languages) in any specific area of the source code 130 and therefcre mix and match the power of both (or any number of) languages without having to sacrifice any.

The example source language is M# and may be compiled Into target code 140 in C# and ASP.NET languages by compiler function 130. For example, M# enables the developer or programmer 10 to write C# or ASP.NET expressions and

statements right Inside the M# source code 120.

An expression or statement written in any programming language may consist of keywcrds identifiers and values. The values could either be constant values or other expressions written in the same language.

In the example N# language, any value can also be written in the target code 140 of C# or ASP.NET. Ihe programmer 10 may specify a piece of code 410 to be in the language of the target code 140 by wrapping, marking up or prefixing such piece of code with a specific keyword or other textual or other identifier. The compiler 130 may then transfer such fragments 410 directly to the relevant area of the generated target code 140 unchanged or apply different compiling functions to them based on their tagged language.

Any two or more of the above Illustrative examples and embodiments may be combined to form a tool, code generator or compiler to provide applications and in particular, web applications.

-21 -As will be appreciated by the skilled person, details of the above embodiment may be varied without departing from the scope of the present invention, as defined by the appended claims.

For example, programming languages other than those mentioned may be used.

Many combinations, modifications, or alterations to the features of the above embodiments will be readily apparent to the skilled person and are intended to form part of the invention. Any of the features described specifically relating to one embodiment or example may be used in any other embodiment by making the appropriate changes.

Claims (22)

1. -22 -CLAIMS: . A computer code editor comprising logic configured to: receive and edit configuration information, wherein the configuration information defines any one or more of: functional requirements, structure, and behaviour of a required application, and display the configuration information in a nested format.
2. 2. The computer code editor of claim 1, wherein the configuration information defines any one or more of: functional requirements, structure, and behaviour of the required application.
3. 3. The computer code editor of claim 1 or claim 2 further comprising a code generator configured to generate code to form the required application from the configuration information.
4. 4. The computer code editor of claim 3, wherein the code generator further comprises a complier.
5. 5. The computer code editor of claim 3 or claim 4, wherein the generated code is source code or executable code.
6. 6. The computer code editor according to any previous claim, wherein the configuration information comprises a plurality of elements and a plurality of sub-elements, wherein one or more sub-elements are associated with an element.

   -23 -
7. 7. The computer code editor of claim 6, wherein the logic is further configured to display the nested format as the elements on a first indentation level and display the sub-elements on a second indentation level, wherein the second indentation level is further indented than the first indentation level.
8. 8. The computer code editor of claim 6 or claim 7, wherein sub-elements associated with an element are displayed directly following the element and grouped together.
9. 9. The computer code editor according to any previous claim, wherein the logic is further configured to display the configuration information in a plain text window.
10. 10. The computer code editor according to any previous claim, wherein the logic is further configured to highlight different nested levels of the configuration information.
11. 11. The computer code editor according to any previous claim, wherein the logic is further configured to highlight elements and sub-elements having the same type in the same way.
12. 12. The computer code editor according to any previous claim, wherein the required application is a web application.
13. 13. A method for assisting with the generation of computer code for a reguired application, the method comprising the steps of: -24 -receiving configuration information for the required application; and displaying the received configuration information in a nested format.
14. 14. The method of claim 13, wherein the configuration information defines any one or more of: functional requirements, structure, and behaviour of the required application.
15. 15. The method of claim 13 or claim 14 further comprising the step of generating code to form the required application from the configuration information.
16. 16. The method according to any of claims 13 to 15, wherein the configuration information comprises a plurality of elements and a plurality of sub-elements, wherein one or more sub-elements are associated with an element.
17. 17. The method according to any of claims 13 to 16, wherein the configuration information is displayed in a single window.
18. 18. A method substantially as described with reference to any of the accompanying drawings.
19. 19. An apparatus substantially as described and shown in any of the accompanying drawings.
20. 20. A computer program comprising program instructions that, when executed on a computer cause the computer to perform the method of any of claims 13 to 18.

    -25 -
21. 21. A computer-readable medium carrying a computer program according to claim 20.
22. 22. A computer programmed to perform the method of any of claims 13 to 18.