Category talk:Solutions by Programming Task

Previous Suggestion for sub-categories

I think the following sub-categories would make sense in addition to the existing Control Structures category (there are probably better names for some of them):

• Basic Data Operations: Here go all the fundamental operations on basic data types.

Articles: Address Operations, Basic pointer and reference operations, Function as an Argument

Add {{basic data operation}} below {{task}} to appropriate articles. --Short Circuit 18:09, 21 March 2007 (EDT)

• Data Structures: Anything covering data structures and how to create and read them. Only the most basic algorithms should be here.

Articles: Assigning Values to an Array, Classes, Collections, Compound Data Type, Create a Sequence of unique elements, Creating an Array, Creating an Associative Array, Data Representation - Controlling Fields in a Structure, Data Representation - Getting the Size, Data Representation - Specifying Minimum Size, Defining Primitive Data Types, Enumeration, Introspection, Polymorphism, Retrieving an Element of an Array, Singly-Linked List (element insertion), Singly-Linked List (element), String Byte Length, String Character Length, Table Creation, Table Creation - Address, Two-dimensional array where both dimensions are given at run time

This category needs to be further parted out into categories representing actual structures, operations inherent to them, and possibly their representation. I did create {{data structure}}, though. It should be placed before {{task}}. --Short Circuit 19:17, 21 March 2007 (EDT)

• Basic algorithms: For all other "pure" algorithms. Those algorithms of course often will make use of the data structures above, but then their point should not the data structure itself, but some operation of it (e.g. sorting, combining two data structures into another one, etc.).

Articles: Apply a callback to an Array, Bubble Sort, Change string case, Copy a string, Creating a Hash from Two Arrays, Increment numerical string, IsNumeric, Product of Array, Regular expression matching, Select from Array, Sorting Using a Custom Comparator, Sorting an Array of Integers, Sum of Array

• Input/Output: Everything related to I/O, serialization or the file system

Articles: DOM XML Serialization, File I/O, Object Serialization, User Input, User Output, Walk Directory, Walk Directory Tree, Zero fill

• Program execution environment: Everything which relates to the environment the program executes in (except that strictly speaking, File I/O also relates to the program's environment).

Articles: Command Line Arguments, Discover the Hostname, Execute a System Command, Fork Proccess

• Concurrency:

Articles: Metered Concurrency, Simple concurrent actions, Synchronous Concurrency

• GUI:

Articles: Creating a Window

• Complex algorithms and applications:

Articles: Creating a SOAP Client, SQL-Based Authentication, Towers of Hanoi, XML and XPath

Regrouping?

Would it make sense to combine many of those file-system kinda things into a single task? In many languages, testing for the existence, readability and size of a file uses effectively the same mechanism/s (E.G. in TCL it would be "file exists $fname" and "file readable $fname" and "file size $fname" etc). I'm not sure it really warrants a "category" if most(?) languages will deliver the answers to all these questions by invocation of the same underlying mechanism. (In IDL you'd call result=file_info(fname) and the result is a structure with elements "result.exists" and "results.read" and "result.size" and so forth; thus all of these are the same task and you simply look at a different elements in the returned structure).

Just a thought ... Sgeier 18:37, 4 October 2007 (MDT)

Well, instead of regrouping, another idea would be to make a "bigger" task which would re-use all the other codes. If I understand what you're saying, you want to make a page which would list almost *everything* you can do with say, file interaction. Would you mind creating a post on the Village Pump to discuss this ? --CrashandDie 01:16, 5 October 2007 (MDT)

Further task divisions

I think this category is getting a bit big. Maybe it could be divided up more than it is now. Category:Programming Tasks can still be a big pile, but this category could be divided. We need some suggestions for new groups, though. Once we have lots of subgroup ideas we can start getting to wiki-work. What do you guys think? --Mwn3d 03:12, 10 August 2008 (UTC)

I'll try to make a few to start with:

• Concurrency:

  Metered Concurrency, Simple concurrent actions, Synchronous Concurrency

• GUI:

  Creating a Window, OpenGL, Simple Windowed Application, User Output - graphical

• Mathematical operations:

• Arithmetic operations:

  Arithmetic Evaluator, Basic integer arithmetic, Complex numbers, Exponentiation operator, Fibonacci sequence, Formal Power Series, Forward difference, Greatest common divisor, Lucas-Lehmer test, Math constants and functions, Maximum Value, Mean, Number base conversion, Numerical Integration, Pascal's Triangle, Roots of a function, Roots of unity, Sum a series, Sum and product of array, Sum of squares, Trigonometric Functions

• Discrete math:

  Bitwise operations, Combinations, Infinity, Monty Hall simulation, Multiplicative order, Non Continuous Subsequences, Power Set

• Encryption:

  MD5, Rot-13, SEDOL

• Fractals:

  Dragon curve, Sierpinski carpet, Sierpinski triangle

• Matrices:

  Matrix Transpose, Matrix exponentiation operator, Matrix multiplication, Spiral, Zig Zag

• Prime Numbers (already made)

• Networking and Web Interaction:

  Creating a SOAP Client, HTTPS request with authentication, Sockets, Web Scraping

• Environment operations

  Command Line Arguments, Connect to Active Directory, Creating a Secure Temporary File, Discover the Hostname, Execute a System Command, Fork Process, Search for a User in Active Directory, System time

• Sorting:

  Sort an array of composite structures, Sorting Using a Custom Comparator, Sorting an Array of Integers

• Sorting Algorithms (already made)

• Basic language learning (can probably be broken up more):

  Array Initialization, Basic input loop, Basic integer arithmetic, Classes, Collections, Command Line Arguments, Comments, Comparing two integers, Compound Data Type, Conditional Structures, Creating a Function, Creating an Array, Creating an Associative Array, Empty Program, Enumeration, Exceptions, Flow Control Structures, Inheritance, Math constants and functions, Null, Program Termination, Quotes, Random Numbers, Retrieving an Element of an Array, Simple Windowed Application, Simple concurrent actions, Sleep the Main Thread, Sockets, Special characters, String length, Two-dimensional array (runtime), User Input, User Output - graphical, User Output - text

• File System Operations (already made)
• Iteration (already made)

• Text Processing:

  Basic input loop, Change string case, Command Line Arguments, Increment numerical string, IsNumeric, Reversing a string, Tokenizing A String

--Mwn3d 18:29, 10 August 2008 (UTC)

Category:Tasks could remain a catch-all category, or that could be moved to Category:All Tasks. As long as Template:Task has been updated, I see no reason this shouldn't proceed. --Short Circuit 03:20, 19 August 2008 (UTC)