8 added 13 characters in body
source | link

This answer is based on the OP'soriginal poster's statement that he has been using Mathematica for six months, and is now trying to build something a bit more complex. I do not take this to mean a large project in the sense that an application developer would use the word.

The notebook interface is really easy to experiment in, and I know that when I had used Mathematica for six months I still needed to test my code very often to make sure it worked. So I used to have a strong preference for the notebook interface. Now I can write much larger pieces of code and be reasonably sure that they will work, so I'm warming up more to IntelliJ which I use sometimes, especially when I am authoring a package.

Unfortunately trying to use both simultaneously - writing on a package in IntelliJ and experimenting with aspects of the package in Mathematica - creates namespace issues that I am usually not willing to fight against, although I have done that too on occasion.


Packages solve mainly three problems in my opinion

  1. Code reuse
  2. Code distribution
  3. Namespace management

If none of these is a concern of yours then you are probably better off writing a notebook in my experience. Note that your mileage with a notebook depends on how you structure it, for larger projects (but not large enough for an IDE) I make use of titles, subtitles and text a lot.

If you find that you have a large code block in a single function then you are probably not writing good, functional code. When you write functional code you want to build up your application gradually using only small functions. The smaller a function is the more testable it is, and this is very important when you are working on a larger project. Otherwise you will find yourself in a situation where you are progressing very slowly because it's hard to debug problems that crop up.

Here is an example of a project with fifty or so functions, but because they have been nested into sensible categories they are all easy to find:

Code example

This answer is based on the OP's statement that he has been using Mathematica for six months, and is now trying to build something a bit more complex. I do not take this to mean a large project in the sense that an application developer would use the word.

The notebook interface is really easy to experiment in, and I know that when I had used Mathematica for six months I still needed to test my code very often to make sure it worked. So I used to have a strong preference for the notebook interface. Now I can write much larger pieces of code and be reasonably sure that they will work, so I'm warming up more to IntelliJ which I use sometimes, especially when I am authoring a package.

Unfortunately trying to use both simultaneously - writing on a package in IntelliJ and experimenting with aspects of the package in Mathematica - creates namespace issues that I am usually not willing to fight against, although I have done that too on occasion.


Packages solve mainly three problems in my opinion

  1. Code reuse
  2. Code distribution
  3. Namespace management

If none of these is a concern of yours then you are probably better off writing a notebook in my experience. Note that your mileage with a notebook depends on how you structure it, for larger projects (but not large enough for an IDE) I make use of titles, subtitles and text a lot.

If you find that you have a large code block in a single function then you are probably not writing good, functional code. When you write functional code you want to build up your application gradually using only small functions. The smaller a function is the more testable it is, and this is very important when you are working on a larger project. Otherwise you will find yourself in a situation where you are progressing very slowly because it's hard to debug problems that crop up.

Here is an example of a project with fifty or so functions, but because they have been nested into sensible categories they are all easy to find:

Code example

This answer is based on the original poster's statement that he has been using Mathematica for six months, and is now trying to build something a bit more complex. I do not take this to mean a large project in the sense that an application developer would use the word.

The notebook interface is really easy to experiment in, and I know that when I had used Mathematica for six months I still needed to test my code very often to make sure it worked. So I used to have a strong preference for the notebook interface. Now I can write much larger pieces of code and be reasonably sure that they will work, so I'm warming up more to IntelliJ which I use sometimes, especially when I am authoring a package.

Unfortunately trying to use both simultaneously - writing on a package in IntelliJ and experimenting with aspects of the package in Mathematica - creates namespace issues that I am usually not willing to fight against, although I have done that too on occasion.


Packages solve mainly three problems in my opinion

  1. Code reuse
  2. Code distribution
  3. Namespace management

If none of these is a concern of yours then you are probably better off writing a notebook in my experience. Note that your mileage with a notebook depends on how you structure it, for larger projects (but not large enough for an IDE) I make use of titles, subtitles and text a lot.

If you find that you have a large code block in a single function then you are probably not writing good, functional code. When you write functional code you want to build up your application gradually using only small functions. The smaller a function is the more testable it is, and this is very important when you are working on a larger project. Otherwise you will find yourself in a situation where you are progressing very slowly because it's hard to debug problems that crop up.

Here is an example of a project with fifty or so functions, but because they have been nested into sensible categories they are all easy to find:

Code example

7 added 10 characters in body
source | link

This answer is based on the OP's statement that he has been using Mathematica for six months, and is now trying to build something a bit more complex. I do not take this to mean a large project in the sense that a WRI employeean application developer would use the word.

The notebook interface is really easy to experiment in, and I know that when I had used Mathematica for six months I still needed to test my code very often to make sure it worked. So I used to have a strong preference for the notebook interface. Now I can write much larger pieces of code and be reasonably sure that they will work, so I'm warming up more to IntelliJ which I use sometimes, especially when I am authoring a package.

Unfortunately trying to use both simultaneously - writing on a package in IntelliJ and experimenting with aspects of the package in Mathematica - creates namespace issues that I am usually not willing to fight against, although I have done that too on occasion.


Packages solve mainly three problems in my opinion

  1. Code reuse
  2. Code distribution
  3. Namespace management

If none of these is a concern of yours then you are probably better off writing a notebook in my experience. Note that your mileage with a notebook depends on how you structure it, for larger projects (but not large enough for an IDE) I make use of titles, subtitles and text a lot.

If you find that you have a large code block in a single function then you are probably not writing good, functional code. When you write functional code you want to build up your application gradually using only small functions. The smaller a function is the more testable it is, and this is very important when you are working on a larger project. Otherwise you will find yourself in a situation where you are progressing very slowly because it's hard to debug problems that crop up.

Here is an example of a project with fifty or so functions, but because they have been nested into sensible categories they are all easy to find:

Code example

This answer is based on the OP's statement that he has been using Mathematica for six months, and is now trying to build something a bit more complex. I do not take this to mean a large project in the sense that a WRI employee would use the word.

The notebook interface is really easy to experiment in, and I know that when I had used Mathematica for six months I still needed to test my code very often to make sure it worked. So I used to have a strong preference for the notebook interface. Now I can write much larger pieces of code and be reasonably sure that they will work, so I'm warming up more to IntelliJ which I use sometimes, especially when I am authoring a package.

Unfortunately trying to use both simultaneously - writing on a package in IntelliJ and experimenting with aspects of the package in Mathematica - creates namespace issues that I am usually not willing to fight against, although I have done that too on occasion.


Packages solve mainly three problems in my opinion

  1. Code reuse
  2. Code distribution
  3. Namespace management

If none of these is a concern of yours then you are probably better off writing a notebook in my experience. Note that your mileage with a notebook depends on how you structure it, for larger projects (but not large enough for an IDE) I make use of titles, subtitles and text a lot.

If you find that you have a large code block in a single function then you are probably not writing good, functional code. When you write functional code you want to build up your application gradually using only small functions. The smaller a function is the more testable it is, and this is very important when you are working on a larger project. Otherwise you will find yourself in a situation where you are progressing very slowly because it's hard to debug problems that crop up.

Here is an example of a project with fifty or so functions, but because they have been nested into sensible categories they are all easy to find:

Code example

This answer is based on the OP's statement that he has been using Mathematica for six months, and is now trying to build something a bit more complex. I do not take this to mean a large project in the sense that an application developer would use the word.

The notebook interface is really easy to experiment in, and I know that when I had used Mathematica for six months I still needed to test my code very often to make sure it worked. So I used to have a strong preference for the notebook interface. Now I can write much larger pieces of code and be reasonably sure that they will work, so I'm warming up more to IntelliJ which I use sometimes, especially when I am authoring a package.

Unfortunately trying to use both simultaneously - writing on a package in IntelliJ and experimenting with aspects of the package in Mathematica - creates namespace issues that I am usually not willing to fight against, although I have done that too on occasion.


Packages solve mainly three problems in my opinion

  1. Code reuse
  2. Code distribution
  3. Namespace management

If none of these is a concern of yours then you are probably better off writing a notebook in my experience. Note that your mileage with a notebook depends on how you structure it, for larger projects (but not large enough for an IDE) I make use of titles, subtitles and text a lot.

If you find that you have a large code block in a single function then you are probably not writing good, functional code. When you write functional code you want to build up your application gradually using only small functions. The smaller a function is the more testable it is, and this is very important when you are working on a larger project. Otherwise you will find yourself in a situation where you are progressing very slowly because it's hard to debug problems that crop up.

Here is an example of a project with fifty or so functions, but because they have been nested into sensible categories they are all easy to find:

Code example

6 added 35 characters in body
source | link

This answer is based on the OP's statement that he has been using Mathematica for six months, and is now trying to build something a bit more complex. I do not take this to mean a large project in the sense that a WRI employee would use the word.

The notebook interface is really easy to experiment in, and I know that when I had used Mathematica for six months I still needed to test my code very often to make sure it worked. So I used to have a strong preference for the notebook interface. Now I can write much larger pieces of code and be reasonably sure that they will work, so I'm warming up more to IntelliJ which I use sometimes, especially when I am authoring a package.

Unfortunately trying to use both simultaneously - writing on a package in IntelliJ and experimenting with aspects of the package in Mathematica - creates namespace issues that I am usually not willing to fight against, although I have done that too on occasion.


Packages solve mainly three problems in my opinion

  1. Code reuse
  2. Code distribution
  3. Namespace management

If none of these is a concern of yours then you are probably better off writing a notebook in my experience. Note that your mileage with a notebook depends on how you structure it, for largelarger projects (but not large enough for an IDE) I make use of titles, subtitles and text a lot.

If you find that you have a large code block in a single function then you are probably not writing good, functional code. When you write functional code you want to build up your application gradually using only small functions. The smaller a function is the more testable it is, and this is very important when you are working on a larger project. Otherwise you will find yourself in a situation where you are progressing very slowly because it's hard to debug problems that crop up.

Here is an example of a project with fifty or so functions, but because they have been nested into sensible categories they are all easy to find:

Code example

This answer is based on the OP's statement that he has been using Mathematica for six months, and is now trying to build something a bit more complex. I do not take this to mean a large project in the sense that a WRI employee would use the word.

The notebook interface is really easy to experiment in, and I know that when I had used Mathematica for six months I still needed to test my code very often to make sure it worked. So I used to have a strong preference for the notebook interface. Now I can write much larger pieces of code and be reasonably sure that they will work, so I'm warming up more to IntelliJ which I use sometimes, especially when I am authoring a package.

Unfortunately trying to use both simultaneously - writing on a package in IntelliJ and experimenting with aspects of the package in Mathematica - creates namespace issues that I am usually not willing to fight against, although I have done that too on occasion.


Packages solve mainly three problems in my opinion

  1. Code reuse
  2. Code distribution
  3. Namespace management

If none of these is a concern of yours then you are probably better off writing a notebook in my experience. Note that your mileage with a notebook depends on how you structure it, for large projects I make use of titles, subtitles and text a lot.

If you find that you have a large code block in a single function then you are probably not writing good, functional code. When you write functional code you want to build up your application gradually using only small functions. The smaller a function is the more testable it is, and this is very important when you are working on larger project. Otherwise you will find yourself in a situation where you are progressing very slowly because it's hard to debug problems that crop up.

Here is an example of a project with fifty or so functions, but because they have been nested into sensible categories they are all easy to find:

Code example

This answer is based on the OP's statement that he has been using Mathematica for six months, and is now trying to build something a bit more complex. I do not take this to mean a large project in the sense that a WRI employee would use the word.

The notebook interface is really easy to experiment in, and I know that when I had used Mathematica for six months I still needed to test my code very often to make sure it worked. So I used to have a strong preference for the notebook interface. Now I can write much larger pieces of code and be reasonably sure that they will work, so I'm warming up more to IntelliJ which I use sometimes, especially when I am authoring a package.

Unfortunately trying to use both simultaneously - writing on a package in IntelliJ and experimenting with aspects of the package in Mathematica - creates namespace issues that I am usually not willing to fight against, although I have done that too on occasion.


Packages solve mainly three problems in my opinion

  1. Code reuse
  2. Code distribution
  3. Namespace management

If none of these is a concern of yours then you are probably better off writing a notebook in my experience. Note that your mileage with a notebook depends on how you structure it, for larger projects (but not large enough for an IDE) I make use of titles, subtitles and text a lot.

If you find that you have a large code block in a single function then you are probably not writing good, functional code. When you write functional code you want to build up your application gradually using only small functions. The smaller a function is the more testable it is, and this is very important when you are working on a larger project. Otherwise you will find yourself in a situation where you are progressing very slowly because it's hard to debug problems that crop up.

Here is an example of a project with fifty or so functions, but because they have been nested into sensible categories they are all easy to find:

Code example

5 deleted 2 characters in body
source | link
4 added 66 characters in body
source | link
3 added 489 characters in body
source | link
2 added 489 characters in body
source | link
1
source | link