#objectoriented — Public Fediverse posts
Live and recent posts from across the Fediverse tagged #objectoriented, aggregated by home.social.
-
YouTrackDB is a general-use object-oriented graph database
https://github.com/JetBrains/youtrackdb
Comments: https://news.ycombinator.com/item?id=48902026
#HackerNews #YouTrackDB #objectoriented #database #graphdatabase #JetBrains #technews
-
YouTrackDB is a general-use object-oriented graph database
https://github.com/JetBrains/youtrackdb
Comments: https://news.ycombinator.com/item?id=48902026
#HackerNews #YouTrackDB #objectoriented #database #graphdatabase #JetBrains #technews
-
YouTrackDB is a general-use object-oriented graph database
https://github.com/JetBrains/youtrackdb
Comments: https://news.ycombinator.com/item?id=48902026
#HackerNews #YouTrackDB #objectoriented #database #graphdatabase #JetBrains #technews
-
YouTrackDB is a general-use object-oriented graph database
https://github.com/JetBrains/youtrackdb
Comments: https://news.ycombinator.com/item?id=48902026
#HackerNews #YouTrackDB #objectoriented #database #graphdatabase #JetBrains #technews
-
YouTrackDB is a general-use object-oriented graph database
https://github.com/JetBrains/youtrackdb
Comments: https://news.ycombinator.com/item?id=48902026
#HackerNews #YouTrackDB #objectoriented #database #graphdatabase #JetBrains #technews
-
@badrihippo modern frameworks like React, Vue, and Van.js are all very similar, but I have not seen a consistent name for this family of frameworks. I have heard it called “The Elm Architecture,” because they are loosely based on how the Elm programming language originally did GUI programming in the browser. I have also heard it called the Model-View-Update paradigm. But most people just call it “React-like” or “Reactive Programming” because they are all similar to the very popular “React.js” framework.
Note that this should not be confused with Functional Reactive Programming (FRP), although the two are not completely different. As I understand it, React-like GUIs and FRP can both be implemented on top of a more powerful and more general computation model called “propagators” (here is the PDF of the original Propagators paper).
@dthompson wrote a really good blog post about FRP, propagators, and React-like frameworks.
I hope that helps, but I am not as well-versed in the theory of this stuff as I should be.
Oh, and I should say, before React-like took over the world wide web, GUI programming was mostly intertwined with Object Oriented Programming and design, so a good place to start might be to read up on Smalltalk OOP and GUI design.
#tech #software #GUI #ReactiveProgramming #FRP #Scheme #Haskell #SchemeLang #Propagators #ElmArchitecture #ReactJS #Smalltalk #OOP #ObjectOriented
-
@badrihippo modern frameworks like React, Vue, and Van.js are all very similar, but I have not seen a consistent name for this family of frameworks. I have heard it called “The Elm Architecture,” because they are loosely based on how the Elm programming language originally did GUI programming in the browser. I have also heard it called the Model-View-Update paradigm. But most people just call it “React-like” or “Reactive Programming” because they are all similar to the very popular “React.js” framework.
Note that this should not be confused with Functional Reactive Programming (FRP), although the two are not completely different. As I understand it, React-like GUIs and FRP can both be implemented on top of a more powerful and more general computation model called “propagators” (here is the PDF of the original Propagators paper).
@dthompson wrote a really good blog post about FRP, propagators, and React-like frameworks.
I hope that helps, but I am not as well-versed in the theory of this stuff as I should be.
Oh, and I should say, before React-like took over the world wide web, GUI programming was mostly intertwined with Object Oriented Programming and design, so a good place to start might be to read up on Smalltalk OOP and GUI design.
#tech #software #GUI #ReactiveProgramming #FRP #Scheme #Haskell #SchemeLang #Propagators #ElmArchitecture #ReactJS #Smalltalk #OOP #ObjectOriented
-
@badrihippo modern frameworks like React, Vue, and Van.js are all very similar, but I have not seen a consistent name for this family of frameworks. I have heard it called “The Elm Architecture,” because they are loosely based on how the Elm programming language originally did GUI programming in the browser. I have also heard it called the Model-View-Update paradigm. But most people just call it “React-like” or “Reactive Programming” because they are all similar to the very popular “React.js” framework.
Note that this should not be confused with Functional Reactive Programming (FRP), although the two are not completely different. As I understand it, React-like GUIs and FRP can both be implemented on top of a more powerful and more general computation model called “propagators” (here is the PDF of the original Propagators paper).
@dthompson wrote a really good blog post about FRP, propagators, and React-like frameworks.
I hope that helps, but I am not as well-versed in the theory of this stuff as I should be.
Oh, and I should say, before React-like took over the world wide web, GUI programming was mostly intertwined with Object Oriented Programming and design, so a good place to start might be to read up on Smalltalk OOP and GUI design.
#tech #software #GUI #ReactiveProgramming #FRP #Scheme #Haskell #SchemeLang #Propagators #ElmArchitecture #ReactJS #Smalltalk #OOP #ObjectOriented
-
@badrihippo modern frameworks like React, Vue, and Van.js are all very similar, but I have not seen a consistent name for this family of frameworks. I have heard it called “The Elm Architecture,” because they are loosely based on how the Elm programming language originally did GUI programming in the browser. I have also heard it called the Model-View-Update paradigm. But most people just call it “React-like” or “Reactive Programming” because they are all similar to the very popular “React.js” framework.
Note that this should not be confused with Functional Reactive Programming (FRP), although the two are not completely different. As I understand it, React-like GUIs and FRP can both be implemented on top of a more powerful and more general computation model called “propagators” (here is the PDF of the original Propagators paper).
@dthompson wrote a really good blog post about FRP, propagators, and React-like frameworks.
I hope that helps, but I am not as well-versed in the theory of this stuff as I should be.
Oh, and I should say, before React-like took over the world wide web, GUI programming was mostly intertwined with Object Oriented Programming and design, so a good place to start might be to read up on Smalltalk OOP and GUI design.
#tech #software #GUI #ReactiveProgramming #FRP #Scheme #Haskell #SchemeLang #Propagators #ElmArchitecture #ReactJS #Smalltalk #OOP #ObjectOriented
-
Rust Is Beyond Object-Oriented, Part 3: Inheritance
https://www.thecodedmessage.com/posts/oop-3-inheritance/
#HackerNews #Rust #ObjectOriented #Inheritance #Programming #HackerNews
-
Rust Is Beyond Object-Oriented, Part 3: Inheritance
https://www.thecodedmessage.com/posts/oop-3-inheritance/
#HackerNews #Rust #ObjectOriented #Inheritance #Programming #HackerNews
-
Rust Is Beyond Object-Oriented, Part 3: Inheritance
https://www.thecodedmessage.com/posts/oop-3-inheritance/
#HackerNews #Rust #ObjectOriented #Inheritance #Programming #HackerNews
-
Rust Is Beyond Object-Oriented, Part 3: Inheritance
https://www.thecodedmessage.com/posts/oop-3-inheritance/
#HackerNews #Rust #ObjectOriented #Inheritance #Programming #HackerNews
-
Rust Is Beyond Object-Oriented, Part 3: Inheritance
https://www.thecodedmessage.com/posts/oop-3-inheritance/
#HackerNews #Rust #ObjectOriented #Inheritance #Programming #HackerNews
-
🚀 Ah, the age-old #debate of why #SQLite isn't coded in your favorite 🦄 object-oriented or 🦺 "safe" language. Spoiler alert: because #C is like a reliable old pickup truck that just won't quit and doesn't care about your trendy hybrid 🚗. #Redditors and Hacker News commenters must be devastated that their "insightful" feedback didn't lead to a full rewrite in Python. 🤯
https://sqlite.org/whyc.html #ObjectOriented #Programming #HackerNews #HackerNews #ngated -
🚀 Ah, the age-old #debate of why #SQLite isn't coded in your favorite 🦄 object-oriented or 🦺 "safe" language. Spoiler alert: because #C is like a reliable old pickup truck that just won't quit and doesn't care about your trendy hybrid 🚗. #Redditors and Hacker News commenters must be devastated that their "insightful" feedback didn't lead to a full rewrite in Python. 🤯
https://sqlite.org/whyc.html #ObjectOriented #Programming #HackerNews #HackerNews #ngated -
🚀 Ah, the age-old #debate of why #SQLite isn't coded in your favorite 🦄 object-oriented or 🦺 "safe" language. Spoiler alert: because #C is like a reliable old pickup truck that just won't quit and doesn't care about your trendy hybrid 🚗. #Redditors and Hacker News commenters must be devastated that their "insightful" feedback didn't lead to a full rewrite in Python. 🤯
https://sqlite.org/whyc.html #ObjectOriented #Programming #HackerNews #HackerNews #ngated -
🚀 Ah, the age-old #debate of why #SQLite isn't coded in your favorite 🦄 object-oriented or 🦺 "safe" language. Spoiler alert: because #C is like a reliable old pickup truck that just won't quit and doesn't care about your trendy hybrid 🚗. #Redditors and Hacker News commenters must be devastated that their "insightful" feedback didn't lead to a full rewrite in Python. 🤯
https://sqlite.org/whyc.html #ObjectOriented #Programming #HackerNews #HackerNews #ngated -
A category is formally defined as being a group of one or more classes.
#OOP #ObjectOriented #ObjectOrientedProgramming
Have you heard of this use of "category" before? If so, in which context/language/compiler?
EDIT: For context, from the #Psion SIBO C SDK's Object Oriented Programming Guide:
A category is formally defined as being a group of one or more classes. The classes are packaged into a load module which, when loaded, occupies a single code segment. A code segment may not contain more than one category. There is, therefore, a one-to-one correspondence between a category and the executable code in a single code segment. Note that this implies that an application that occupies a single code segment may not contain more than one category.
-
A category is formally defined as being a group of one or more classes.
#OOP #ObjectOriented #ObjectOrientedProgramming
Have you heard of this use of "category" before? If so, in which context/language/compiler?
EDIT: For context, from the #Psion SIBO C SDK's Object Oriented Programming Guide:
A category is formally defined as being a group of one or more classes. The classes are packaged into a load module which, when loaded, occupies a single code segment. A code segment may not contain more than one category. There is, therefore, a one-to-one correspondence between a category and the executable code in a single code segment. Note that this implies that an application that occupies a single code segment may not contain more than one category.
-
A category is formally defined as being a group of one or more classes.
#OOP #ObjectOriented #ObjectOrientedProgramming
Have you heard of this use of "category" before? If so, in which context/language/compiler?
EDIT: For context, from the #Psion SIBO C SDK's Object Oriented Programming Guide:
A category is formally defined as being a group of one or more classes. The classes are packaged into a load module which, when loaded, occupies a single code segment. A code segment may not contain more than one category. There is, therefore, a one-to-one correspondence between a category and the executable code in a single code segment. Note that this implies that an application that occupies a single code segment may not contain more than one category.
-
A category is formally defined as being a group of one or more classes.
#OOP #ObjectOriented #ObjectOrientedProgramming
Have you heard of this use of "category" before? If so, in which context/language/compiler?
EDIT: For context, from the #Psion SIBO C SDK's Object Oriented Programming Guide:
A category is formally defined as being a group of one or more classes. The classes are packaged into a load module which, when loaded, occupies a single code segment. A code segment may not contain more than one category. There is, therefore, a one-to-one correspondence between a category and the executable code in a single code segment. Note that this implies that an application that occupies a single code segment may not contain more than one category.
-
A category is formally defined as being a group of one or more classes.
#OOP #ObjectOriented #ObjectOrientedProgramming
Have you heard of this use of "category" before? If so, in which context/language/compiler?
EDIT: For context, from the #Psion SIBO C SDK's Object Oriented Programming Guide:
A category is formally defined as being a group of one or more classes. The classes are packaged into a load module which, when loaded, occupies a single code segment. A code segment may not contain more than one category. There is, therefore, a one-to-one correspondence between a category and the executable code in a single code segment. Note that this implies that an application that occupies a single code segment may not contain more than one category.
-
@chakie #Python #ObjectOriented
Question.
I have written #PySide classes to implement editable multi-segment lines for both straight lines and hermite splines. The interfaces are identical, barring the spline constructor, which takes a tangent list.
I want to create a parent class `PolyLine` which can either be `straight` or `hermite`. A "Strategy Pattern" _seems_ to be the solution, but it feels complex. Putting an `if` into every method feels worse.
Ideas?
Code: https://codeberg.org/GrantH/Pyside6-PolyLines/src/branch/main/ -
@chakie #Python #ObjectOriented
Question.
I have written #PySide classes to implement editable multi-segment lines for both straight lines and hermite splines. The interfaces are identical, barring the spline constructor, which takes a tangent list.
I want to create a parent class `PolyLine` which can either be `straight` or `hermite`. A "Strategy Pattern" _seems_ to be the solution, but it feels complex. Putting an `if` into every method feels worse.
Ideas?
Code: https://codeberg.org/GrantH/Pyside6-PolyLines/src/branch/main/ -
@chakie #Python #ObjectOriented
Question.
I have written #PySide classes to implement editable multi-segment lines for both straight lines and hermite splines. The interfaces are identical, barring the spline constructor, which takes a tangent list.
I want to create a parent class `PolyLine` which can either be `straight` or `hermite`. A "Strategy Pattern" _seems_ to be the solution, but it feels complex. Putting an `if` into every method feels worse.
Ideas?
Code: https://codeberg.org/GrantH/Pyside6-PolyLines/src/branch/main/ -
@chakie #Python #ObjectOriented
Question.
I have written #PySide classes to implement editable multi-segment lines for both straight lines and hermite splines. The interfaces are identical, barring the spline constructor, which takes a tangent list.
I want to create a parent class `PolyLine` which can either be `straight` or `hermite`. A "Strategy Pattern" _seems_ to be the solution, but it feels complex. Putting an `if` into every method feels worse.
Ideas?
Code: https://codeberg.org/GrantH/Pyside6-PolyLines/src/branch/main/ -
@chakie #Python #ObjectOriented
Question.
I have written #PySide classes to implement editable multi-segment lines for both straight lines and hermite splines. The interfaces are identical, barring the spline constructor, which takes a tangent list.
I want to create a parent class `PolyLine` which can either be `straight` or `hermite`. A "Strategy Pattern" _seems_ to be the solution, but it feels complex. Putting an `if` into every method feels worse.
Ideas?
Code: https://codeberg.org/GrantH/Pyside6-PolyLines/src/branch/main/ -
An Efficient Implementation of Self, a Dynamically-Typed Object-Oriented Langua [pdf]
https://courses.cs.washington.edu/courses/cse501/15sp/papers/chambers.pdf
#HackerNews #EfficientImplementation #Self #DynamicallyTyped #ObjectOriented #Language #PDF
-
An Efficient Implementation of Self, a Dynamically-Typed Object-Oriented Langua [pdf]
https://courses.cs.washington.edu/courses/cse501/15sp/papers/chambers.pdf
#HackerNews #EfficientImplementation #Self #DynamicallyTyped #ObjectOriented #Language #PDF
-
An Efficient Implementation of Self, a Dynamically-Typed Object-Oriented Langua [pdf]
https://courses.cs.washington.edu/courses/cse501/15sp/papers/chambers.pdf
#HackerNews #EfficientImplementation #Self #DynamicallyTyped #ObjectOriented #Language #PDF
-
An Efficient Implementation of Self, a Dynamically-Typed Object-Oriented Langua [pdf]
https://courses.cs.washington.edu/courses/cse501/15sp/papers/chambers.pdf
#HackerNews #EfficientImplementation #Self #DynamicallyTyped #ObjectOriented #Language #PDF
-
An Efficient Implementation of Self, a Dynamically-Typed Object-Oriented Langua [pdf]
https://courses.cs.washington.edu/courses/cse501/15sp/papers/chambers.pdf
#HackerNews #EfficientImplementation #Self #DynamicallyTyped #ObjectOriented #Language #PDF
-
Found a way to identify the science kids in my programming class..
OOP Review: We are all all inherited from fish right?
#programming #science #scishow #hankgreen #oop #software #genetics #fish #teaching #objectoriented
-
Found a way to identify the science kids in my programming class..
OOP Review: We are all all inherited from fish right?
#programming #science #scishow #hankgreen #oop #software #genetics #fish #teaching #objectoriented
-
Found a way to identify the science kids in my programming class..
OOP Review: We are all all inherited from fish right?
#programming #science #scishow #hankgreen #oop #software #genetics #fish #teaching #objectoriented
-
Found a way to identify the science kids in my programming class..
OOP Review: We are all all inherited from fish right?
#programming #science #scishow #hankgreen #oop #software #genetics #fish #teaching #objectoriented
-
Open Humanities Press has published a 2nd edition of Timothy Morton's Realist Magic: Objects, Ontology, Causality. Comes complete with a new preface by Morton.
Like all OHP books, Realist Magic is available open access:
https://www.openhumanitiespress.org/books/titles/realist-magic-2nd-ed/
Book description
#ObjectOriented ontology offers a startlingly fresh way to think about causality that takes into account developments in #physics since 1900. Causality, argues Object Oriented Ontology (OOO), is #aesthetic. In this book, Timothy Morton explores what it means to say that a thing has come into being, that it is persisting, and that it has ended. Drawing from examples in #physics, #biology, #ecology, #art, #literature and #music, Morton demonstrates the counterintuitive yet elegant explanatory power of OOO for thinking causality.
The book is published as part of the New Metaphysics series:
https://www.openhumanitiespress.org/books/series/new-metaphysics/
-
Open Humanities Press has published a 2nd edition of Timothy Morton's Realist Magic: Objects, Ontology, Causality. Comes complete with a new preface by Morton.
Like all OHP books, Realist Magic is available open access:
https://www.openhumanitiespress.org/books/titles/realist-magic-2nd-ed/
Book description
#ObjectOriented ontology offers a startlingly fresh way to think about causality that takes into account developments in #physics since 1900. Causality, argues Object Oriented Ontology (OOO), is #aesthetic. In this book, Timothy Morton explores what it means to say that a thing has come into being, that it is persisting, and that it has ended. Drawing from examples in #physics, #biology, #ecology, #art, #literature and #music, Morton demonstrates the counterintuitive yet elegant explanatory power of OOO for thinking causality.
The book is published as part of the New Metaphysics series:
https://www.openhumanitiespress.org/books/series/new-metaphysics/
-
Open Humanities Press has published a 2nd edition of Timothy Morton's Realist Magic: Objects, Ontology, Causality. Comes complete with a new preface by Morton.
Like all OHP books, Realist Magic is available open access:
https://www.openhumanitiespress.org/books/titles/realist-magic-2nd-ed/
Book description
#ObjectOriented ontology offers a startlingly fresh way to think about causality that takes into account developments in #physics since 1900. Causality, argues Object Oriented Ontology (OOO), is #aesthetic. In this book, Timothy Morton explores what it means to say that a thing has come into being, that it is persisting, and that it has ended. Drawing from examples in #physics, #biology, #ecology, #art, #literature and #music, Morton demonstrates the counterintuitive yet elegant explanatory power of OOO for thinking causality.
The book is published as part of the New Metaphysics series:
https://www.openhumanitiespress.org/books/series/new-metaphysics/
-
Open Humanities Press has published a 2nd edition of Timothy Morton's Realist Magic: Objects, Ontology, Causality. Comes complete with a new preface by Morton.
Like all OHP books, Realist Magic is available open access:
https://www.openhumanitiespress.org/books/titles/realist-magic-2nd-ed/
Book description
#ObjectOriented ontology offers a startlingly fresh way to think about causality that takes into account developments in #physics since 1900. Causality, argues Object Oriented Ontology (OOO), is #aesthetic. In this book, Timothy Morton explores what it means to say that a thing has come into being, that it is persisting, and that it has ended. Drawing from examples in #physics, #biology, #ecology, #art, #literature and #music, Morton demonstrates the counterintuitive yet elegant explanatory power of OOO for thinking causality.
The book is published as part of the New Metaphysics series:
https://www.openhumanitiespress.org/books/series/new-metaphysics/
-
Open Humanities Press has published a 2nd edition of Timothy Morton's Realist Magic: Objects, Ontology, Causality. Comes complete with a new preface by Morton.
Like all OHP books, Realist Magic is available open access:
https://www.openhumanitiespress.org/books/titles/realist-magic-2nd-ed/
Book description
#ObjectOriented ontology offers a startlingly fresh way to think about causality that takes into account developments in #physics since 1900. Causality, argues Object Oriented Ontology (OOO), is #aesthetic. In this book, Timothy Morton explores what it means to say that a thing has come into being, that it is persisting, and that it has ended. Drawing from examples in #physics, #biology, #ecology, #art, #literature and #music, Morton demonstrates the counterintuitive yet elegant explanatory power of OOO for thinking causality.
The book is published as part of the New Metaphysics series:
https://www.openhumanitiespress.org/books/series/new-metaphysics/
-
What's in a name? that which we call as a method
By any other name would work as correctly.
(After WS.)We say "comma-separated values", but we do
>>> ','.join(("foo", "bar", "baz"))
'foo,bar,baz'Wherefore art thou Joiner—or Separator...
#ComputerProgramming
#Names
#Naming
#ObjectCentric
#ObjectOriented
#Paraphrases
#ProgrammingLanguages
#RJ
#Rose -
What's in a name? that which we call as a method
By any other name would work as correctly.
(After WS.)We say "comma-separated values", but we do
>>> ','.join(("foo", "bar", "baz"))
'foo,bar,baz'Wherefore art thou Joiner—or Separator...
#ComputerProgramming
#Names
#Naming
#ObjectCentric
#ObjectOriented
#Paraphrases
#ProgrammingLanguages
#RJ
#Rose -
What's in a name? that which we call as a method
By any other name would work as correctly.
(After WS.)We say "comma-separated values", but we do
>>> ','.join(("foo", "bar", "baz"))
'foo,bar,baz'Wherefore art thou Joiner—or Separator...
#ComputerProgramming
#Names
#Naming
#ObjectCentric
#ObjectOriented
#Paraphrases
#ProgrammingLanguages
#RJ
#Rose -
What's in a name? that which we call as a method
By any other name would work as correctly.
(After WS.)We say "comma-separated values", but we do
>>> ','.join(("foo", "bar", "baz"))
'foo,bar,baz'Wherefore art thou Joiner—or Separator...
#ComputerProgramming
#Names
#Naming
#ObjectCentric
#ObjectOriented
#Paraphrases
#ProgrammingLanguages
#RJ
#Rose -
What's in a name? that which we call as a method
By any other name would work as correctly.
(After WS.)We say "comma-separated values", but we do
>>> ','.join(("foo", "bar", "baz"))
'foo,bar,baz'Wherefore art thou Joiner—or Separator...
#ComputerProgramming
#Names
#Naming
#ObjectCentric
#ObjectOriented
#Paraphrases
#ProgrammingLanguages
#RJ
#Rose -
estoy tan harto de hacer #refactor de codigo #csharp de 2010-2015 "estructurado" a algo parecido a #objectoriented 😩
-
estoy tan harto de hacer #refactor de codigo #csharp de 2010-2015 "estructurado" a algo parecido a #objectoriented 😩
-
CW: #rstats hivemind assistance request: How to structure a program to change the algebraic properties of an arithmetic calculation independent of the structure of the calculation?
#rstats hivemind assistance request:
How to structure an #rstats program to change the algebraic properties of an arithmetic calculation independent of the structure of the calculation?
(I want this in #rstats because it's the only programming language in which I am non-negatively competent.)I have some simple arithmetic calculations structured as data flow graphs like the one below (where each node corresponds to an algebraic operator). I want to investigate the effect of changing the algebraic properties of the operators (in this example, addition and multiplication) while keeping the structure of the calculation constant.
[EDIT] I may eventually want to vary the algebraic properties of the operators per node in the data flow graph. For example, addition may work differently at different nodes in the days flow graph.
This is analogous to having an #rstats arithmetic expression (e..g. a + b * c) and changing the types of the operands (e.g. int, double, complex). The structure of the arithmetic expression stays constant and the operators just "do the right thing" dependent on the type of the operands.
Obviously, I will have to program the operators. For the types of algebraic operators I am considering I am reasonably confident that I can get away with representing the operands as #rstats primitive numeric types (int, double, or complex). That is, I am not contemplating algebras where the operands have to be composite structures like graphs or matrices.
Also, I want all the operands to be *vectors* of values of the same type, so that vectorised arithmetic just works in the standard #rstats fashion.
I am presuming the idiomatic way to do this in #rstats would involve object-oriented programming with me writing methods for the operators and dispatching on the types of the operands.
Given a choice, I would prefer an approach that minimises the code I have to write and minimises the extent to which I have to turn my brain inside-out to comprehend what I am doing (because I am a mediocre programmer, at best).
The implementation doesn't have to be blazingly fast, but I can't afford it to be pitch-drop slow (https://en.wikipedia.org/wiki/Pitch_drop_experiment). A typical experiment will consist of a few thousand replicates of a recurrent calculation consisting of maybe 10 operations on vectors of 10,000 elements, carried out for 100 iterations.
So:
1) What #rstats programming approach would you suggest for solving this problem?
2) Is there an idiots' guide to something similar that I might be able to follow and adapt?Thanks in advance.
-
CW: #rstats hivemind assistance request: How to structure a program to change the algebraic properties of an arithmetic calculation independent of the structure of the calculation?
#rstats hivemind assistance request:
How to structure an #rstats program to change the algebraic properties of an arithmetic calculation independent of the structure of the calculation?
(I want this in #rstats because it's the only programming language in which I am non-negatively competent.)I have some simple arithmetic calculations structured as data flow graphs like the one below (where each node corresponds to an algebraic operator). I want to investigate the effect of changing the algebraic properties of the operators (in this example, addition and multiplication) while keeping the structure of the calculation constant.
[EDIT] I may eventually want to vary the algebraic properties of the operators per node in the data flow graph. For example, addition may work differently at different nodes in the days flow graph.
This is analogous to having an #rstats arithmetic expression (e..g. a + b * c) and changing the types of the operands (e.g. int, double, complex). The structure of the arithmetic expression stays constant and the operators just "do the right thing" dependent on the type of the operands.
Obviously, I will have to program the operators. For the types of algebraic operators I am considering I am reasonably confident that I can get away with representing the operands as #rstats primitive numeric types (int, double, or complex). That is, I am not contemplating algebras where the operands have to be composite structures like graphs or matrices.
Also, I want all the operands to be *vectors* of values of the same type, so that vectorised arithmetic just works in the standard #rstats fashion.
I am presuming the idiomatic way to do this in #rstats would involve object-oriented programming with me writing methods for the operators and dispatching on the types of the operands.
Given a choice, I would prefer an approach that minimises the code I have to write and minimises the extent to which I have to turn my brain inside-out to comprehend what I am doing (because I am a mediocre programmer, at best).
The implementation doesn't have to be blazingly fast, but I can't afford it to be pitch-drop slow (https://en.wikipedia.org/wiki/Pitch_drop_experiment). A typical experiment will consist of a few thousand replicates of a recurrent calculation consisting of maybe 10 operations on vectors of 10,000 elements, carried out for 100 iterations.
So:
1) What #rstats programming approach would you suggest for solving this problem?
2) Is there an idiots' guide to something similar that I might be able to follow and adapt?Thanks in advance.
-
CW: #rstats hivemind assistance request: How to structure a program to change the algebraic properties of an arithmetic calculation independent of the structure of the calculation?
#rstats hivemind assistance request:
How to structure an #rstats program to change the algebraic properties of an arithmetic calculation independent of the structure of the calculation?
(I want this in #rstats because it's the only programming language in which I am non-negatively competent.)I have some simple arithmetic calculations structured as data flow graphs like the one below (where each node corresponds to an algebraic operator). I want to investigate the effect of changing the algebraic properties of the operators (in this example, addition and multiplication) while keeping the structure of the calculation constant.
[EDIT] I may eventually want to vary the algebraic properties of the operators per node in the data flow graph. For example, addition may work differently at different nodes in the days flow graph.
This is analogous to having an #rstats arithmetic expression (e..g. a + b * c) and changing the types of the operands (e.g. int, double, complex). The structure of the arithmetic expression stays constant and the operators just "do the right thing" dependent on the type of the operands.
Obviously, I will have to program the operators. For the types of algebraic operators I am considering I am reasonably confident that I can get away with representing the operands as #rstats primitive numeric types (int, double, or complex). That is, I am not contemplating algebras where the operands have to be composite structures like graphs or matrices.
Also, I want all the operands to be *vectors* of values of the same type, so that vectorised arithmetic just works in the standard #rstats fashion.
I am presuming the idiomatic way to do this in #rstats would involve object-oriented programming with me writing methods for the operators and dispatching on the types of the operands.
Given a choice, I would prefer an approach that minimises the code I have to write and minimises the extent to which I have to turn my brain inside-out to comprehend what I am doing (because I am a mediocre programmer, at best).
The implementation doesn't have to be blazingly fast, but I can't afford it to be pitch-drop slow (https://en.wikipedia.org/wiki/Pitch_drop_experiment). A typical experiment will consist of a few thousand replicates of a recurrent calculation consisting of maybe 10 operations on vectors of 10,000 elements, carried out for 100 iterations.
So:
1) What #rstats programming approach would you suggest for solving this problem?
2) Is there an idiots' guide to something similar that I might be able to follow and adapt?Thanks in advance.
-
CW: #rstats hivemind assistance request: How to structure a program to change the algebraic properties of an arithmetic calculation independent of the structure of the calculation?
#rstats hivemind assistance request:
How to structure an #rstats program to change the algebraic properties of an arithmetic calculation independent of the structure of the calculation?
(I want this in #rstats because it's the only programming language in which I am non-negatively competent.)I have some simple arithmetic calculations structured as data flow graphs like the one below (where each node corresponds to an algebraic operator). I want to investigate the effect of changing the algebraic properties of the operators (in this example, addition and multiplication) while keeping the structure of the calculation constant.
[EDIT] I may eventually want to vary the algebraic properties of the operators per node in the data flow graph. For example, addition may work differently at different nodes in the days flow graph.
This is analogous to having an #rstats arithmetic expression (e..g. a + b * c) and changing the types of the operands (e.g. int, double, complex). The structure of the arithmetic expression stays constant and the operators just "do the right thing" dependent on the type of the operands.
Obviously, I will have to program the operators. For the types of algebraic operators I am considering I am reasonably confident that I can get away with representing the operands as #rstats primitive numeric types (int, double, or complex). That is, I am not contemplating algebras where the operands have to be composite structures like graphs or matrices.
Also, I want all the operands to be *vectors* of values of the same type, so that vectorised arithmetic just works in the standard #rstats fashion.
I am presuming the idiomatic way to do this in #rstats would involve object-oriented programming with me writing methods for the operators and dispatching on the types of the operands.
Given a choice, I would prefer an approach that minimises the code I have to write and minimises the extent to which I have to turn my brain inside-out to comprehend what I am doing (because I am a mediocre programmer, at best).
The implementation doesn't have to be blazingly fast, but I can't afford it to be pitch-drop slow (https://en.wikipedia.org/wiki/Pitch_drop_experiment). A typical experiment will consist of a few thousand replicates of a recurrent calculation consisting of maybe 10 operations on vectors of 10,000 elements, carried out for 100 iterations.
So:
1) What #rstats programming approach would you suggest for solving this problem?
2) Is there an idiots' guide to something similar that I might be able to follow and adapt?Thanks in advance.
-
CW: #rstats hivemind assistance request: How to structure a program to change the algebraic properties of an arithmetic calculation independent of the structure of the calculation?
#rstats hivemind assistance request:
How to structure an #rstats program to change the algebraic properties of an arithmetic calculation independent of the structure of the calculation?
(I want this in #rstats because it's the only programming language in which I am non-negatively competent.)I have some simple arithmetic calculations structured as data flow graphs like the one below (where each node corresponds to an algebraic operator). I want to investigate the effect of changing the algebraic properties of the operators (in this example, addition and multiplication) while keeping the structure of the calculation constant.
[EDIT] I may eventually want to vary the algebraic properties of the operators per node in the data flow graph. For example, addition may work differently at different nodes in the days flow graph.
This is analogous to having an #rstats arithmetic expression (e..g. a + b * c) and changing the types of the operands (e.g. int, double, complex). The structure of the arithmetic expression stays constant and the operators just "do the right thing" dependent on the type of the operands.
Obviously, I will have to program the operators. For the types of algebraic operators I am considering I am reasonably confident that I can get away with representing the operands as #rstats primitive numeric types (int, double, or complex). That is, I am not contemplating algebras where the operands have to be composite structures like graphs or matrices.
Also, I want all the operands to be *vectors* of values of the same type, so that vectorised arithmetic just works in the standard #rstats fashion.
I am presuming the idiomatic way to do this in #rstats would involve object-oriented programming with me writing methods for the operators and dispatching on the types of the operands.
Given a choice, I would prefer an approach that minimises the code I have to write and minimises the extent to which I have to turn my brain inside-out to comprehend what I am doing (because I am a mediocre programmer, at best).
The implementation doesn't have to be blazingly fast, but I can't afford it to be pitch-drop slow (https://en.wikipedia.org/wiki/Pitch_drop_experiment). A typical experiment will consist of a few thousand replicates of a recurrent calculation consisting of maybe 10 operations on vectors of 10,000 elements, carried out for 100 iterations.
So:
1) What #rstats programming approach would you suggest for solving this problem?
2) Is there an idiots' guide to something similar that I might be able to follow and adapt?Thanks in advance.
-
CW: grumpy comment about Shiffman wrapping everything in classes (OO)
I love Daniel Shiffman and the people porting NOC examples, but their insistence on wrapping everything in classes, and in this particular example, to put them on separate files... Take this L-System example: https://github.com/nature-of-code/noc-2-processing-port/blob/main/chapter8/Example_8_9_LSystem/Example_8_9_LSystem.pde
And the JS original: https://natureofcode.com/fractals/#l-systems (you have to open the p5js editor and click a lot to find the lsystem.js file)
In my view it doesn't help at all learners grasp what is going on to have to switch to two other tabs to look at a few lines of code that could be two functions.
Ignore for a moment it's Python and compare the previous code to these procedural implementations:
https://abav.lugaralgum.com/material-aulas/Processing-Python-py5/LSystem.html(Now, I take back the "ignore for a moment it's Python", and I suggest you marvel at the elegance of the Python dict)
#natureofcode #Processing #LSystem #Python #JavaScript #ObjectOriented #procedural
-
CW: grumpy comment about Shiffman wrapping everything in classes (OO)
I love Daniel Shiffman and the people porting NOC examples, but their insistence on wrapping everything in classes, and in this particular example, to put them on separate files... Take this L-System example: https://github.com/nature-of-code/noc-2-processing-port/blob/main/chapter8/Example_8_9_LSystem/Example_8_9_LSystem.pde
And the JS original: https://natureofcode.com/fractals/#l-systems (you have to open the p5js editor and click a lot to find the lsystem.js file)
In my view it doesn't help at all learners grasp what is going on to have to switch to two other tabs to look at a few lines of code that could be two functions.
Ignore for a moment it's Python and compare the previous code to these procedural implementations:
https://abav.lugaralgum.com/material-aulas/Processing-Python-py5/LSystem.html(Now, I take back the "ignore for a moment it's Python", and I suggest you marvel at the elegance of the Python dict)
#natureofcode #Processing #LSystem #Python #JavaScript #ObjectOriented #procedural
-
CW: grumpy comment about Shiffman wrapping everything in classes (OO)
I love Daniel Shiffman and the people porting NOC examples, but their insistence on wrapping everything in classes, and in this particular example, to put them on separate files... Take this L-System example: https://github.com/nature-of-code/noc-2-processing-port/blob/main/chapter8/Example_8_9_LSystem/Example_8_9_LSystem.pde
And the JS original: https://natureofcode.com/fractals/#l-systems (you have to open the p5js editor and click a lot to find the lsystem.js file)
In my view it doesn't help at all learners grasp what is going on to have to switch to two other tabs to look at a few lines of code that could be two functions.
Ignore for a moment it's Python and compare the previous code to these procedural implementations:
https://abav.lugaralgum.com/material-aulas/Processing-Python-py5/LSystem.html(Now, I take back the "ignore for a moment it's Python", and I suggest you marvel at the elegance of the Python dict)
#natureofcode #Processing #LSystem #Python #JavaScript #ObjectOriented #procedural
-
CW: grumpy comment about Shiffman wrapping everything in classes (OO)
I love Daniel Shiffman and the people porting NOC examples, but their insistence on wrapping everything in classes, and in this particular example, to put them on separate files... Take this L-System example: https://github.com/nature-of-code/noc-2-processing-port/blob/main/chapter8/Example_8_9_LSystem/Example_8_9_LSystem.pde
And the JS original: https://natureofcode.com/fractals/#l-systems (you have to open the p5js editor and click a lot to find the lsystem.js file)
In my view it doesn't help at all learners grasp what is going on to have to switch to two other tabs to look at a few lines of code that could be two functions.
Ignore for a moment it's Python and compare the previous code to these procedural implementations:
https://abav.lugaralgum.com/material-aulas/Processing-Python-py5/LSystem.html(Now, I take back the "ignore for a moment it's Python", and I suggest you marvel at the elegance of the Python dict)
#natureofcode #Processing #LSystem #Python #JavaScript #ObjectOriented #procedural
-
CW: grumpy comment about Shiffman wrapping everything in classes (OO)
I love Daniel Shiffman and the people porting NOC examples, but their insistence on wrapping everything in classes, and in this particular example, to put them on separate files... Take this L-System example: https://github.com/nature-of-code/noc-2-processing-port/blob/main/chapter8/Example_8_9_LSystem/Example_8_9_LSystem.pde
And the JS original: https://natureofcode.com/fractals/#l-systems (you have to open the p5js editor and click a lot to find the lsystem.js file)
In my view it doesn't help at all learners grasp what is going on to have to switch to two other tabs to look at a few lines of code that could be two functions.
Ignore for a moment it's Python and compare the previous code to these procedural implementations:
https://abav.lugaralgum.com/material-aulas/Processing-Python-py5/LSystem.html(Now, I take back the "ignore for a moment it's Python", and I suggest you marvel at the elegance of the Python dict)
#natureofcode #Processing #LSystem #Python #JavaScript #ObjectOriented #procedural
-
Loglan'82: programming language for object-oriented and distributed programming
https://lem12.uksw.edu.pl/wiki/Loglan%2782_project
#HackerNews #Loglan82 #ObjectOriented #Programming #DistributedProgramming #ProgrammingLanguages #HackerNews