Definition of algorithm

Currently the definition of algorithm is: "A Directive Information Content Entity that prescribes the inputs and output of mathematical functions as well as workflow of execution for achieving an predefined objective." It contains a typo: an predefined --> a predefined.
Anyway, the biggest issue is that, I think, the definition is wrong, at least the part about mathematical functions. An algorithm does not prescribe inputs or outputs (in some sense of "prescribe", that is the job of the definition of a function). An algorithm is a finite list of commands 1) each of which requires only a finite amount of information and resources (energy, time, paper, etc.) to be carried out and such that 2) the entire process of implementing the algorithm on a given input is deterministic (i.e. every agent that follows the same algorithm and begins with the same input carries out the same operations producing, along the way, the same results in the same order). Note that an algorithmically specified procedure may not terminate, i.e. the output may not exist. For a reference, you can see Soare, Turing Computability pp. 3 ff.

@Mttbnchtt Thanks for the catch on typo.

An algorithm does not prescribe inputs or outputs

Not sure I completely understand your concern. I agree it doesn't prescribe the specifics of the inputs and outputs. But, at the minimum, doesn’t an algorithm generically prescribe the number, order, and formatting of inputs and outputs?

@mark-jensen I think I agree with @Mttbnchtt. Here's a dictionary definition of algorithm (from the OED):

A procedure or set of rules used in calculation and problem-solving; (in later use spec.) a precisely defined set of mathematical or logical operations for the performance of a particular task.

By these lights, CCO's definition seems awfully specific. What is the motivation for referencing mathematical functions? In practice, only a small fraction of algorithms derive from mathematical functions. In particular, mathematical functions are typically considered stateless, whereas algorithms can modify state.
One can infer an algorithm's inputs and outputs from its set of operations, but to my mind the operations are the fundamental aspect of the concept. CCO, with its "as well as workflow" description, demotes that aspect.

Hi @mark-jensen. I still think that an algorithm does not prescribe inputs or outputs. The algorithm is a finite list of rules. These rules will typically be applicable to some inputs and not to some others, but that is not stated in the algorithm. The number of inputs that a function takes is also not necessarily mentioned in an algorithm. We could have a function f(x, y) that takes two input and the algorithm that describes how to compute the result may simply be:  copy x on the output slot and halt (there is no mention of the second input). An algorithmically specified function may not have an output (for example, the algorithm may cause the computing agent to loop forever).
It is important to notice that an algorithm is not any list of rules. The list must be finite, the rules (individually but not necessarily collectively) must be finitely implementable, and the process must be deterministic. An additional condition that I forgot before (but it is usually required) is that the list must be consistent: i.e. the algorithm cannot ask the agent to do different things in the same situation.
Finally, this is not required to solve our issue, but it is better to say that explicitly: in classical mathematics, not every function is algorithmically specifiable (there are so-called constructive views of mathematics in which every function is algorithmically specifiable, but they are not mainstream math).

Thanks @Mttbnchtt @swartik for your feedback. I agree that use of mathematical function seems too restrictive. Let's work here to improve the definition.
Note: the CCO term in its current state derives from IAO. A search of their tracker finds several stale issues working to refine their definition with no results. Moreover, there is a clear history of struggle amongst experts in computational theory and philosophy to reach agreement on a universal definition for 'algorithm'. Thus, we should be modest in our goal and aim for stepwise improvement.
First draft at revision:
algorithm = "A Directive Information Content Entity that prescribes a finite sequence of deterministic operations that can be automated to achieve an objective."
Please offer suggestions for improvement

Hi @mark-jensen. I think the draft is good. I have three observations:

Where I can find the definition of "directive information content entity"?
Leaving aside more contentious issues (as you rightly suggest), one part of the draft that still needs attention is "to achieve an objective", where "objective" is defined as follows: A Directive Information Content Entity that prescribes some projected state that some Agent intends to achieve.
In the context of an algorithm, I think most naturally of an objective as being the output of the process prescribed by the algorithm given a specific input. However, the process prescribed by an algorithm may not have an output (e.g.: write 1, delete 1, repeat).
The definition of objective is more general than output, and one may think that the carrying out of the process on a given input is the objective, regardless of whether the process terminates or not. This is possible, given the above definition of "objective", although unnatural and, in the end, irrelevant to the definition of algorithm.
An algorithm is a finite sequence of instructions. However, the sequence of operations that it prescribes may not be finite (see example above).

I am not familiar with the selected vocabulary of CCOs. Is there a way to re-state the following definitions within the CCOs:
algorithm= a finite sequence of instructions each of which can be automated?

@Mttbnchtt, CCO defines "Directive Information Content Entity" as the superclass of Algorithm and Objective, among other classes. Its definition is:

An Information Content Entity that consists of a set of propositions or images (as in the case of a blueprint) that prescribe some Entity.

@mark-jensen, I'm trying to think of how to rewrite the definition to use as many CCO terms as possible. Unfortunately, CCO doesn't include either "instruction" or "operation". In the sense you intend, they are themselves Directive Information Content Entities.
I think "deterministic" is too strict. "Sort the array" is a legitimate step in an algorithm, but it doesn't tell me whether to use a stable sorting algorithm.
So with those concerns in mind, I propose the following revision:

algorithm = "A Directive Information Content Entity that prescribes a finite sequence of operations that can be automated to achieve an Objective."

This should be accompanied by an elucidation explaining what "finite sequence of operations" means.
If you agree I'll be happy to work on the elucidation. (For the record, I'm still pondering whether I prefer "operation" or "instruction".)

Thanks @swartik for the clarification. About the definition of algorithm, there are two major problems the revision that is proposed: "A Directive Information Content Entity that prescribes a finite sequence of operations that can be automated to achieve an Objective".

What is finite in an algorithm is the list of prescriptions, not of operations (or, at least, it is ambiguous to say that it is). Under some possible reading, the sequence of operations may be infinite, as long as I can specify that using only finitely many orders. This is an example: (a) add 1, (b) repeat. The list of orders is finite (there are two orders). The list of operations that it prescribes is infinite because one would keep adding 1 forever.

Implementing an algorithm may not lead to an output. For example, implementing the algorithm above, one keeps adding 1 and never gives a result. In this sense, it is not clear that the algorithm prescribes something "to achieve an Objective".

The notion of instruction (order, command, etc.) is really central to the notion of algorithm. I fear that we will not be able to define algorithm properly if do not use the notion of instruction. Is it htat complicated to add it to the ontology?

@Mttbnchtt,
I think agree with you about "operation" vs. "instruction". However, @mark-jensen proposed "operation", and I would like him to weigh in so I can understand his motivation before I commit.
As for whether repeatedly adding 1 doesn't achieve an objective, I'm not so sure. You are right that it has no output. I could therefore say that your algorithm achieves the objective of demonstrating that an algorithm need not have an output. You as the algorithm's creator must have had an objective in mind when you stated the algorithm. That objective has nothing to do with the instructions' effects.
Alternately, CCO might argue, and quite reasonably I think, that "algorithm" in its context is limited to instructions combined to achieve an objective. Of course, that would have to be stated clearly and explicitly.

Thanks @swartik. I see that could be reasonable here to concentrate on algorithm given to produce an objective. s for operation vs instruction, I agree that we should hear from @mark-jensen first.

@swartik @Mttbnchtt Thanks for the thoughtful feedback. Apologies for delay in response.
A Directive ICE is (in a sense) an instruction, or composed of instructions, or commands. What it prescribes are operations, i.e., processes. We can drop use of 'operations' to make it more clear. The question is do we want to restrict algorithms to prescribe only computer processes? I think so.
Iterating:

cco:Algorithm =def "A Directive Information Content Entity that prescribes some Computer Program Execution process and contains a finite sequence of unambiguous instructions in order to achieve some Objective."

And yes, having an objective doesn't necessarily imply an output or termination.

@swartik @Mttbnchtt Thanks for the thoughtful feedback. Apologies for delay in response.
A Directive ICE is (in a sense) an instruction, or composed of instructions, or commands. What it prescribes are operations, i.e., processes. We can drop use of 'operations' to make it more clear. The question is do we want to restrict algorithms to prescribe only computer processes? I think so.
Iterating:

cco:Algorithm =def "A Directive Information Content Entity that prescribes some Computer Program Execution process and contains a finite sequence of unambiguous instructions in order to achieve some Objective."

And yes, having an objective doesn't necessarily imply an output or termination.

@mark-jensen Your definition definitely improves consistency with CCO.
Is Computer Program Execution a proposed class? I can't find it in either the master branch or bfo2020.

@mark-jensen Your definition definitely improves consistency with CCO.
Is Computer Program Execution a proposed class? I can't find it in either the master branch or bfo2020.

Thanks Mark. Just seen this. I will reread the discussion. Will reply later
today.
On Fri, Jan 22, 2021 at 5:10 PM swartik<EMAIL_ADDRESS>wrote:

@mark-jensen https://github.com/mark-jensen Your definition definitely
improves consistency with CCO.
Is Computer Program Execution a proposed class? I can't find it in either
the master branch or bfo2020.
—
You are receiving this because you were mentioned.
Reply to this email directly, view it on GitHub
https://github.com/CommonCoreOntology/CommonCoreOntologies/issues/46#issuecomment-765712553,
or unsubscribe
https://github.com/notifications/unsubscribe-auth/AIND3OLR4NOEQBIZUHUOEMLS3HZUNANCNFSM4H2RL22A
.

Thanks Mark. Just seen this. I will reread the discussion. Will reply later
today.
On Fri, Jan 22, 2021 at 5:10 PM swartik<EMAIL_ADDRESS>wrote:

@mark-jensen https://github.com/mark-jensen Your definition definitely
improves consistency with CCO.
Is Computer Program Execution a proposed class? I can't find it in either
the master branch or bfo2020.
—
You are receiving this because you were mentioned.
Reply to this email directly, view it on GitHub
https://github.com/CommonCoreOntology/CommonCoreOntologies/issues/46#issuecomment-765712553,
or unsubscribe
https://github.com/notifications/unsubscribe-auth/AIND3OLR4NOEQBIZUHUOEMLS3HZUNANCNFSM4H2RL22A
.

Sorry that I reply late. I think that Mark's definition of algorithm is ok
now. To be sure I should know the definition of Computer Program Execution.
If it implies that the execution is bounded by the energy of the universe
or the life of the universe, which may be finite, then I disagree. For
example, given a finite amount of time, there are Turing computable
functions that will require longer to compute. Or even more simply, a
non-terminating algorithm will run forever but it is still an algorithm.
On Thu, 28 Jan 2021 at 13:07, Matteo Bianchetti @.***> wrote:

Thanks Mark. Just seen this. I will reread the discussion. Will reply
later today.
On Fri, Jan 22, 2021 at 5:10 PM swartik @.***> wrote:

@mark-jensen https://github.com/mark-jensen Your definition definitely
improves consistency with CCO.
Is Computer Program Execution a proposed class? I can't find it in either
the master branch or bfo2020.
—
You are receiving this because you were mentioned.
Reply to this email directly, view it on GitHub
https://github.com/CommonCoreOntology/CommonCoreOntologies/issues/46#issuecomment-765712553,
or unsubscribe
https://github.com/notifications/unsubscribe-auth/AIND3OLR4NOEQBIZUHUOEMLS3HZUNANCNFSM4H2RL22A
.

@swartik My mistake. ComputerProgramExecution isn't in Mid-level CCO. I am tempted to amend the def. to be more general, to not restrict only to operations performed by a CPU, but include potential for other types of processes being prescribed by an algorithm.

cco:Algorithm =def "A Directive Information Content Entity that prescribes some Process and contains a finite sequence of unambiguous instructions in order to achieve some Objective.

@Mttbnchtt I think generalizing to a BFO process also would address your concern of an algorithm prescribing a non-terminating process.

Agree. Thanks Mark.
On Mon, Mar 15, 2021 at 3:09 PM Mark Jensen @.***>
wrote:

@swartik https://github.com/swartik My mistake. ComputerProgramExecution
isn't in Mid-level CCO. I am tempted to amend the def. to be more general,
to not restrict only to operations performed by a CPU, but include
potential for other types of processes being prescribed by an algorithm.
cco:Algorithm =def "A Directive Information Content Entity that prescribes
some Process and contains a finite sequence of unambiguous instructions in
order to achieve some Objective.
@Mttbnchtt https://github.com/Mttbnchtt I think generalizing to a BFO
process also would address your concern of an algorithm prescribing a
non-terminating process.
—
You are receiving this because you were mentioned.
Reply to this email directly, view it on GitHub
https://github.com/CommonCoreOntology/CommonCoreOntologies/issues/46#issuecomment-799679866,
or unsubscribe
https://github.com/notifications/unsubscribe-auth/AIND3ON3EAF2Q73EPKUGLXDTDZLNPANCNFSM4H2RL22A
.

@mark-jensen offers:

algorithm = "A Directive Information Content Entity that prescribes a finite sequence of deterministic operations that can be automated to achieve an objective."

There may be problems with finite and deterministic wording. I'm also not clear whether the intended sense is limited to computer programs. The wikipedia article uses the phrase "perform a computation". I'd go with that.
Finite: There are algorithms that don't quite match this. For example, FOL reasoning algorithms  may land up in an infinite loop, which is typically cut off based on resources, for instance how long it takes, or how much memory is allowed. The specification of those resource limitations may or may not be included in the algorithm, since usually those are specific to a platform.   In other words the number of steps in computation that the algorithm prescribes may not be finite. I think this might be resolved by putting finite on the other side of prescribes. or, it could be left out without harm.
Deterministic: Some algorithms are not by their nature deterministic, for example the class of "probably almost correct" algorithms or algorithms which reduce to probabilistic Turing machines or ones that deal with the unpredictable in the real world.
What do we know about algorithms? They aren't dependent on what programming language they are implemented in, but can be expressed in different programming languages. They describe computations. They are designed so that when an implementation is run it achieves an objective.
I'm not sure exactly how to express all this, at the moment. The IAO definition has some of this, but it's not perfect either. The following at least omits the parts that are suspect.
"A Directive Information Content Entity that prescribes a sequence of computations that achieve an objective"
or this, which captures the idea that there is an implementation intermediate:
"A Directive Information Content Entity that prescribes computer programs which when executed achieve an objective"

Thanks very much for the further proposal. There is some misunderstanding
concerning the finiteness requirement. This is my biggest worry with the
comment above. The execution of an algorithm does not need to be finite.
The list of instructions (and each instruction) needs to be finite. An
infinite list of instructions is not (or, anyhow, does not specify) an
algorithm. Could we correct the original definition "A Directive
Information Content Entity that prescribes a finite sequence of
deterministic operations that can be automated to achieve an objective" as
follows:
"A FINITE Directive Information Content Entity that UNAMBIGUOUSLY
prescribes a sequence of operations that, IN PRINCIPLE, can be automated"?
I am not sure whether we can say that a directive information content
entity is finite (I do not recall the definition), but we must find a way
to express that concept. Only finite lists of finite instructions (i.e.
finite lists of symbols expressing a content) are algorithms (otherwise
every real number or, equivalently, every subset of the natural numbers,
would be computable). I want to stress that this part is necessary: the
presentation of the instructions must be finite (though the implementation
of the instructions need not be).
I would also say that the prescription of the steps must be unambiguous
(there is no guessing or artistic or personal interpretation that can take
place). I would also say that the sequence of operations can be automated
in principle to avoid confusion with what is technologically or physically
possible (e.g. there can be a computation that exceeds the age of the
universe; though physically impossible it still counts as a computation in
mathematics). I would take away the "to achieve an objective" part: it is
harmless (if we take that in some rarified sense) but also useless (because
whatever happens in a computation can be interpreted as achieving an
objective, so it does not distinguish anything from anything).
On a minor point in the previous message: "perform a computation" evokes
some meanings of "performance" (like artistic performance) that do not
refer to mechanical processes. If we need to say something like that, I
suggest using "carry out a computation" (or "execute a computation" or,
more simply, "compute"). But I do not see the need to use such expressions,
given the suggestion above. Thanks very much.
On Sun, 21 Mar 2021 at 00:05, Alan Ruttenberg @.***>
wrote:

@mark-jensen https://github.com/mark-jensen offers:
algorithm = "A Directive Information Content Entity that prescribes a
finite sequence of deterministic operations that can be automated to
achieve an objective."
There may be problems with finite and deterministic wording. I'm also not
clear whether the intended sense is limited to computer programs. The
wikipedia article uses the phrase "perform a computation". I'd go with that.
Finite: There are algorithms that don't quite match this. For example, FOL
reasoning algorithms may land up in an infinite loop, which is typically
cut off based on resources, for instance how long it takes, or how much
memory is allowed. The specification of those resource limitations may or
may not be included in the algorithm, since usually those are specific to a
platform. In other words the number of steps in computation that the
algorithm prescribes may not be finite. I think this might be resolved by
putting finite on the other side of prescribes. or, it could be left out
without harm.
Deterministic: Some algorithms are not by their nature deterministic, for
example the class of "probably almost correct" algorithms or algorithms
which reduce to probabilistic Turing machines
https://en.wikipedia.org/wiki/Probabilistic_Turing_machine or ones that
deal with the unpredictable in the real world.
What do we know about algorithms? They aren't dependent on what
programming language they are implemented in, but can be expressed in
different programming languages. They describe computations. They are
designed so that when an implementation is run it achieves an objective.
I'm not sure exactly how to express all this, at the moment. The IAO
definition http://purl.obolibrary.org/obo/IAO_0000064 has some of this,
but it's not perfect either. The following at least omits the parts that
are suspect.
"A Directive Information Content Entity that prescribes a sequence of
computations that achieve an objective"
or this, which captures the idea that there is an implementation
intermediate:
"A Directive Information Content Entity that prescribes computer programs
which when executed achieve an objective"
—
You are receiving this because you were mentioned.
Reply to this email directly, view it on GitHub
https://github.com/CommonCoreOntology/CommonCoreOntologies/issues/46#issuecomment-803508646,
or unsubscribe
https://github.com/notifications/unsubscribe-auth/AIND3OMLJCRO6GYG5S7BUODTEVWAPANCNFSM4H2RL22A
.

@Mttbnchtt, there are two things about 'finite'. I wrote something about this in my comments, saying that the finite requirement made more sense on the left hand side - the side of the directive information entity, than on the other side, the operations. As I re-read that part I realize it's more ambiguous than how I, at first, understood it. The thing is that 'operation' in CS connotes what the computer is doing, e.g. MFLOPs, or IOPs. So I read 'operation' as what the computer was doing, and my comments follow that interpretation. So, what I meant by being on left hand side is that it is the algorithm has a specific number of parts.
However, a second aspect that I didn't touch on is that in realist ontologies, which is what we are making in following BFO, there's no such thing as infinite. Our universe is finite, time until the heat death of the universe is finite, the number of particles in the universe is finite. Correspondingly, anything and anything that happens in the universe is finite. So "finite" doesn't really add anything in a definition.
Closer to the intent is whether there's a known limit or not. That's captured, for instance, by the idea of decidability in computational complexity theory.  That said, I don't think that saying something about this here is useful. Ask what the difference in the extension (members) of the class of algorithms given a definition with and without the condition. Can we find an example where only not satisfying the 'finite' condition is what rules out the example being a member of the class? If not, then discard it since it has no utility in discriminating.
As to directive information entity, I don't think CCO's IAO captures the story as well as OBO's IAO does. With information entities, which are generically dependent continuants,  we talk about concretizations of the information entity. For a novel, the information entity is the content and the concretizations are the print in each physical book. The book is the information bearer. The information entity is what is the same about all the copies.
Usually, concretizations are qualities - the pattern of ink in the book or the pattern of pixels on a screen - the book or screen being the information bearer/ bearer of the concretization. For a directive information entity we say that the concretization can also be a realizable entity. Realizable entities are what you have that explains how you act in some situation. In IAO, a plan specification is like a written version of what should happen. The realizable entity is the thing you have that has a direct relation (realizes) to acts. The realizable entity is the internalized plan, so to speak. So, that there's a specified path between a directive information entity and the act the the directive is about is what distinguishes them from the rest of the information entities.
Performance: It is exactly that. it means it is what happens. It's a performance not because it's art but because performing is a process and that process is guided by an information artifact, a program. It's colloquial to talk about performing an operation and in that sense there's no connotation that art is involved. In art it might be a music score or a script that is the information artifact. That said, for my purpose, 'executing' is synonymous. So, I don't mind that as an alternative. I'm not sure what you mean by mechanical.
I think the shape of my second definition better captures the intent. It makes it clear there are least three things: The algorithm (the thing that is the same in all implementations), the implementation (the program), and the execution of the program.  It also removes the ambiguity of "operation".
Regarding your proposed definition:

A FINITE Directive Information Content Entity that UNAMBIGUOUSLY prescribes a sequence of operations that, IN PRINCIPLE, can be automated

I like the "in principle" part. It capture the aspect of realizable entities in that they may or may not be realized. You may be the designated driver (a role) but it may happen that the car you were going to use doesn't start and the gang lands up taking an Uber, and so the role is not realized. So, being a realizable entity captures possibility. I've already said why I think 'finite' is unnecessary. I'm not sure if 'ambiguous' helps. Can you give me an example of something that's almost an algorithm, except for the fact that it is ambiguous?
There's a sense in which and algorithm is actually deliberately ambiguous in that an algorithm doesn't specify exactly how some steps are done. For instance, if an algorithm says that a multiplication is done, the multiplication can be done in different ways. In typical CPUs there's a hardware implementation and you just issue the instruction. But, a cheap microcontroller might not have a multiplication unit and it instead needs to do the multiplication is implemented in software. Any correct algorithm for multiplication would be fine to use as a basis for that software. So the algorithm is at least unspecific, and it's not far to go from unspecific to ambiguous.

mark-jensen offers:
algorithm = "A Directive Information Content Entity that prescribes a finite sequence of deterministic operations that can be automated to achieve an objective."

@alanruttenberg This definition was an early iteration in attempting to improve the original. See comments from last week, currently it is:

cco:Algorithm =def "A Directive Information Content Entity that prescribes some Process and contains a finite sequence of unambiguous instructions in order to achieve some Objective.

We removed the use of 'deterministic' for reasons you describe. The use of 'finite' and 'unambiguous' applies to the instructions themselves, not the particular implementaion or process that carries them out.
Admittedly, use of "in order to achieve some Objective" is redundant, and not really needed, as all Directives prescribe in order to achieve an objective.
You suggest that the entity that is prescribed is:

a sequence of computations

Are you suggesting to use 'computation' as a primitive and perhaps only elucidate? Or rather, attempt to define something akin to a computational process?
I'm amenable to inlcuding something about computation and automation, but think offering a formal def. for computation might lead us down a rabbit hole.
Iterating:

cco:Algorithm =def "A Directive Information Content Entity that contains a finite sequence of unambiguous instructions and prescribes the computations to be carried out in some Process, which in principle can be automated.

elucidation: We use 'computation' here is in the sense of ... [careful wording that doesn't invite Pandora]

Note we have a term in CCO-mid Mechanical Process and a subclass curated in Cyber Ontology Computer Program Execution. If need, we can refactor these accordingly depending on the outcome of this discussion, but ignoring their existence would hinder progress at this point.

cco:ComputerProgramExecution = A Mechanical Process that is comprised of a sequence of simple operations performed by a Central Processing Unit or some Computer Program according to the instructions of some Algorithm.

I think best for our definition of Algorithm to not address the nature of computation in a way that goes beyond closed system and automated processess that artifacts are capable of. Ideally it would also not rule out other types of computation that organic or quantum systems exhibit. That is a tall order though, so we should remain humble in our attempt.

This comment is criticism. Later I'll write something constructive.

cco:Algorithm =def "A Directive Information Content Entity that contains a finite sequence of unambiguous instructions and prescribes the computations to be carried out in some Mechanical Process, which in principle can be automated.

Mechanical process: A Process that is the realization of some Disposition of an Artifact

ComputerProgramExecution = A Mechanical Process that is comprised of a sequence of simple operations performed by a Central Processing Unit or some Computer Program according to the instructions of some Algorithm.

Quick comments:

See my comments above re:finite and unambiguous
Some things mechanical process def seems to allow
-- The changing color of a ph strip
-- A glass breaking when it falls down
-- The outgassing of a new foam mattress
-- The sandpaper I'm using wearing out
-- The burning of a match
-- My digital thermometer displaying a temperature
-- A fingerprint reader determining whether there's a match
"according to the instructions of some algorithm" -> "prescribed by some algorithm" (the computer program is what's prescribed).

Are all those intended? For the most part, they don't seem to me to fit into the common sense of mechanical.
ComputerProgramExecution

Doesn't work for quantum computers, which are programmed.
It is the instructions that are simple, not the consequences of the instructions.
"Central Processing Unit or some Computer Program" -> the CPU (or quantum thingy)  does the operations, not the program.

I'm not sure I agree with the goal "Ideally it would also not rule out other types of computation that organic or quantum systems exhibit"
DNA is not an information content entity. It is a different kind of GDC. ICEs are artifactual. In the case of organic or natural quantum systems 'computing', I'm of the opinion that such characterizations are concepts - ways to understand natural phenomena in terms of systems we've built and understand. That doesn't mean they are the same sort of things as the those systems.
Quantum computers do computations. Natural quantum processes (pretty much anything that happens) do not all fall under computation and do not execute algorithms, which are human constructed things. Non-intentionally built things do not prescribe.
I concur on the goal of being humble in our attempts. To me that means sticking to a narrower definition of a term we understand now, and then building generalizations when and if we understand more. If it's thought that there's some larger sense of algorithm, then define 'computer algorithm' for now and reserve 'algorithm' for when we're smart enough to figure out the generalization.

the complexity of the procedure is determined. Therefore, all implementational minutiae are specified as well.

This doesn't follow. The minutiae may vary in the way I mentioned in the earlier message. The only constraint from computational complexity is that the complexity of the implementation of a step is the same (or better) than what it is in the algorithm.
As I understand the Turing paper, the distinction being made is between computable and not-computable numbers - and is related to the notion of decidability. The mentions of infinity should be understood as in principle mentions and stand in contrast to the uncomputable numbers, a great example of which is Chaitin’s constant. That number isn't even in principle computable. Turing can't be used as an authoritative voice on whether the universe can accommodate the infinite as even now that is not known. When mathematicians talk about the infinite it is not (usually) in the physical sense and access to it is not given by physics. Rather, it is arrived at by things like limits and induction.
As an aside, for an entertaining take on finiteness and numbers check out Greg Egan's story Dark Integers
Inclusion of the finiteness criterion doesn't hurt (much) but it doesn't help either because, as far as I know, there's no sensible alternative to algorithm that differs only on the finiteness criterion. So, it doesn't make a difference/isn't suitable as a differentia. There's an implicature that conditions that are mentioned in a definition are meaningful. When they are not, including them is a tax on understanding.
My earlier comment raises a number of issues with the definition, only one of which is the use of "finite". I still don't really understand the term mechanical process and I list a number of processes that I'm asking about in order to understand it. Hopefully we can get back to addressing those in the interest of coming up with a suitable definition.
You are right that we aren't writing the authoritative definition. To me that means we should create a definition that's narrowly scoped, has an operational way of evaluating whether a given instance of information content entity is an algorithm, and where the meaning of common use of the label doesn't excessively differ from the definition.
To be clear, this isn't a personal criticism of the initial efforts to define the term nor an attempt to be overly philosophical. I look at all definitions in the same way - as a practical way of determining whether an instance is in or is outside the class. I test that by thinking of examples that are close to what I think the boundaries of the definition are and then checki with the author as to what they intended. If a definition doesn't let me do that or if parts of the definitions are not germane to that task then I aim to get it fixed.
Definitions can't always do all the work. That's why it's a good practice, in such cases, to give examples of usage as well as cases that seem close to the edge but are on the wrong side.

Alan, in the informal sense, an algorithm does not specify every detail. In the formal sense studied by computability and complexity theory it does. Saying "add n to m" is not an instruction in a formally specified algorithm, even if in more relaxed contexts it could count as such. In a formal setting, "add n to m" would be said to refer to a function (addition) that can be specified by different algorithms (each algorithm giving instructions that leave no room for alternative moves, once the inputs are given). If not, the complexity of a procedure would indeed not be determined by the algorithm, given the inputs.
For the second point. I mentioned the computability of the number \pi to indicate that we cannot limit computations to what machines can do in the actual universe. The reason is that we cannot provide a fixed finite upper bound to the resources (time, space, energy, etc.) that a computation may take. If computations were limited by the existence span of the universe, then \pi would be uncomputable, but it is computable. I raised this point because some comment above made me worry that, given that our ontology is a realist one, mentioning mechanical processes may imply a fixed finite upper bound to the resources available to the mechanical process. If that is not the case, we can ignore this observation.
There still seems to be some confusion about the role of finiteness in an algorithm. It is essential for each instruction to be finite and for the list of instructions to be finite. This is a necessary condition, not an idle one: otherwise, every real number would be computable. Our definition should either say that explicitly or imply it (implicature is not good enough when capturing a formal notion). Moreover, every computation that provides an output uses only a finite amount of resources. However, there is no fixed finite upper bound to the size of the input, the size of the output, the length of an instruction, the length of the list, the resources used by the computation. That is all we need to consider regarding the issue finite vs infinite in this context. The "in principle" part of the definition is meant to indicate the absence of a fixed finite upper bound of this type.

Matteo, "add m to n" is the COBOL syntax for incrementing n by m. I mention this detail not to call attention to my being an old geezer, but to ask whether the point of your first paragraph should deal with ambiguity rather than the particular set of tokens used to express addition. If an instruction has an unambiguous interpretation under some syntactic interpretation, it's possible to create a programming language incorporating that syntax. If there is no unambiguous interpretation (something like "increment n by the correct amount") I agree with your first paragraph.

@swartik : I was taking "add n to m" to be an English sentence. If in COBOL this string of symbols constraints ach move of every implementer of it, then it can be used in an algorithm (in the formal sense of algorithm), as you say. In English that string of symbol does not have an unambiguous interpretation (my Italian teacher taught me a method that, albeit slightly, is different than what my son's American teacher is teaching him; of course both methods lead to the same result and define the same function).

In a formal setting, "add n to m" would be said to refer to a function (addition) that can be specified by different algorithms (each algorithm giving instructions that leave no room for alternative moves, once the inputs are given). If not, the complexity of a procedure would indeed not be determined by the algorithm, given the inputs. That said, if we want to define the informal notion of algorithm, that is ok with me as long as we clarify the objective.

While there are, theoretically, algorithms for the individual steps, a given algorithm (formal or informal) typically do not mention them.  I'm not sure why my assertion is controversial. Implementation happens at multiple levels in computer systems. There's the level of the computer program, the steps that it is compiled to, the particular implementation of a CPU. Instructions may be directly implemented in hardware, may be specified by microcode, may be coalesced, such as when a CPU does a multiple and add instruction instead of the two step add and multiply, and may even implement an instruction in different ways depending on the state of the machine.
I think we've beat this to death. I we can't agree on it at this point then we will have to agree to disagree. There are a host of other issues I've raised regarding the definition and that of mechanical process on which it is based. In the interest of moving forward, perhaps we can turn to those other issues.

@alanruttenberg : a computer program like a python script is not an algorithm in the sense in which computability and complexity theory considers it. It is an algorithm only in an informal sense (assuming we call formal the mathematically exact sense of algorithm studied in computability and complexity theory). The reason is what you say: a python script does not specify every detail of the behavior of a computer. If we want to define an algorithm as a computer script (where a computer is, for example, what Apple produces), I am ok. However, as I tried to explain, I am considering the mathematical definition of an algorithm (where also a computer is a theoretical concept see, e.g., the infinite tape of Turing machines). I think we have to agree on what we discuss, not so much on the fact that computer programs are not algorithms in the formal sense. My insistence on non-ambiguity is standard in computability theory, not my choice (see. Rogers, Theory of recursive functions $1.1 and Soare, Turing comuability, §1.2). You need it to prove, e.g., Goedel's first incompleteness theorem.
I am not competent discussing your questions about mechanical process as defined in this ontology. I defer to you and Mark, except noting, as above, that "mechanical" in computability theory is not what "mechanical" means in physics.

I thought of a counterexample for all the definitions offered. Algorithms that employ an oracle. In determining the complexity of such algorithms the oracle can give a 1 step answer to a problem that is unsolvable, i.e. where no implementation is possible.  In those cases there's no minutiae to be had nor can a program be written that accomplishes the goal of the algorithm.
So, it's back to the drawing board. One approach would be to avoid the problem by using a narrower definition that excludes such algorithms. Having a definition that captures all the senses in which it is used in language is desirable but sometimes not advisable. In the end it's definition that matters. The label and documentation should be written for the purpose of best communicating the class.
The other approach is to try to make a definition that works for the oracle case. I'm thinking that a principal difference between an algorithm and a program is the intent in creating it. Algorithms can be used for both both for determining complexity as well as being a guide in writing programs. Programs, for the most part, are written for the purpose of controlling what a computer does. There may be other goals, such writing a program as an entry to a competition where the winner is whoever writes the shortest program that works.

Thanks, Alan. I think it is a good idea to define algorithm as one does in computability theory and define programs to capture what computer scientists writes (also called algorithms in a less formal sense).
I do not think that the oracle computation changes the definition of algorithm though, which, in the formal sense, is still a finite list etc. When one introduces oracle computation in computability theory, all that changes is that instructions of a new type (more or less "ask the oracle") are allowed. There is no change concerning the unambiguity of each instruction. What we should consider is that, in the sense of algorithm used in computability, given the inputs and the oracle, the complexity of the computation is given.

@Mttbnchtt, Mark's definition proposal was:

A Directive Information Content Entity that contains a finite sequence of unambiguous instructions and prescribes the computations to be carried out in some Mechanical Process, which in principle can be automated.

An algorithm using an oracle answering, say, whether some program halts can't prescribe the computations to be carried out, because there is no process that can compute whether a program halts.

I'm leaning toward the idea of, instead of defining algorithm, defining something like "realizable computing algorithm" with a definition that is specific to compute science/programming and is limited to algorithms that can actually can be implemented. Or, it could be slightly more restrictive by not including any algorithms using oracles.  A recipe is not a realizable computer algorithm in this sense, nor instructions in a repair manual, though some people might call those algorithms. We could have "algorithm" as an alternative label, if desired.

Alan, an oracle is not part of an algorithm. It is information stored somewhere. In a Turing machine it is on a tape that the head can read. The tape could contain the decimal expansion of an incomputable number but that is not relevant. We do not require the information on the oracle tape to be generated by a computation or algorithmically: it is given (like an oracle delivering a message from a god, hence the name). The algorithm is something separate from the oracle.
The algorithm of a machine with an oracle would still prescribe a computation. The computation could include actions like retrieving information from the oracle. Nothing changes in the (formal) definition of what an algorithm is by allowing actions of this type to be prescribed.

There is a concrete, incremental improvement in this thread that I have tried to capture under https://github.com/CommonCoreOntology/CommonCoreOntologies/issues/411 . The rest of this thread I will move into the discussion forum for further refinement of this issue.


[Feature Request] add subtitles features

Acknowledgements

[X] I have searched the existing issues and this is a new ticket, NOT a duplicate or related to another open issue.
[X] I have written a short but informative title.
[X] If this is an issue with an extension, I should be opening an issue in the extensions repository.
[X] I have updated the app to the latest version.
[X] I will fill out all of the requested information in this form.

Describe your suggested feature
I think it could look like the vlc subtitle feature, we just make a search on the app (by informing : the name of the anime, the season, the episode) and we find what subtitle we need while to watch the video. There are sites that makes subtitles like OpenSubtitles (for example), we just download the subtitles and put it on the video (I know it won't be that simple to automate that on a app). The advantage will be that we will be able to watch the video even if we don't understand english.
But all this can be use only if there aren't already subtitles so we first need japanese source...
Other details
https://www.opensubtitles.org (OpenSubtitles)

Yeah same thoughts. I should be needed to see anime in English with English subtitles. But that place if i Played anime English language,it was not showing the English subtitles. Better then atleast we need to add feature like subtitles add From our local storage device. Kindly consider this request.

Seriously, I have latest version aniyomi (V 12.3.10 )I checked whole application and setting.. But I can't see Opensubtitle Anyplace.. Could you tell me how I would use that feature..

I don't know where to have the subtitles

plsss i need an open subtitles or a subtitle on a English movie plsss


Pn532 reliability?

I find pn532 to not work reliably (at least with this library, haven't tried C libraries so can't say if it is only device issues or maybe software issue), is there something that can be configured for it to be more reliable?
Issues I face -

I needed to work with I2C ver low frequency (20kHz), while I read it should be able to work at MHz - which maybe make it more reliable in case the tag moves a bit while reading because it is faster?
Quite a few times it doesn't recognize tag even when very close
Many times it begins to read and fails after several pages, I do retries but many times they still fail, with error codes 1, 2 or 11. Even begin with some error, then switch to another
It is very sensitive to distance of tag (sometimes tag is too near actually and need to be further away).
Sometimes the device goes into an error state (while all I'm doing is reading/writing)

Are there any configurations available to tune the behavior?
Any thoughts about implementing this library also for pn7160 which I read is more reliable?

Yeah, reliability is not great in my experience as well.
I've also seen the issues you describe come up with the exception of I2C frequency.
What are the errors you're getting when using 100 kHz I2C? With I2C cable length and pull-up resistor sizing can be issues. Maybe you can analyze your signals with a scope to check for noise and rise-times.
I've found that EMI and metal near the tag can lead to problems.

Are there any configurations available to tune the behavior?

Unfortunately I don't know, if you figure something out, let me know :)

Any thoughts about implementing this library also for pn7160 which I read is more reliable?

Does it use a similar protocol?

Any thoughts about implementing this library also for pn7160 which I read is more reliable?

Does it use a similar protocol?

I don't know since I don't know the pn532 protocol either.
I guess it's different but its also by NXP so maybe there are similarities.
It's a replacement for pn532.
I read somewhere that pn532 manufacturing ended, don't know how reliable that information is.
This is the user-manual:
https://www.nxp.com/docs/en/user-manual/UM11495.pdf

With I2C cable length and pull-up resistor sizing can be issues. Maybe you can analyze your signals with a scope to check for noise and rise-times.

Do I need to add resistors with I2C? I just connect it directly to Esp32 with around 20cm wires.
Is SPI more reliable and easier from that respect? I couldn't get it to work at all. Do you happen to have example code for esp32 that work with SPI?

This is the user-manual: https://www.nxp.com/docs/en/user-manual/UM11495.pdf

Looks very different to me, so I don't think there's much code that can be shared here.

Do I need to add resistors with I2C? I just connect it directly to Esp32 with around 20cm wires.

Yes, absolutely. 4.7k or 10k are typical values. You might want to have a read online.

Is SPI more reliable and easier from that respect? I couldn't get it to work at all. Do you happen to have example code for esp32 that work with SPI?

SPI tends to be more reliable in my experience.
I believe your implementation from #22 wasn't quite correct. Since the cs handling is now part of the SpiDevice trait one needed to be sure, to stick bytes that belong together into a single transaction. Maybe you want to give SPI another try with #25

Yes, absolutely. 4.7k or 10k are typical values. You might want to have a read online.

Doesn't the Esp32 have the pull-ups internally?

Yes, but those are much larger than 10k

I gave SPI another try, couldn't get it to work (with esp32).
Below is the code, anything wrong with it? I get TimeoutAck.
I set the dip-switches on the module to spi.
    let sck = peripherals.GPIO14;
    let mosi = peripherals.GPIO13;
    let miso = peripherals.GPIO12;
    let cs = Output::new(peripherals.GPIO15, Level::High);

    let spi = Spi::new_with_config(
        peripherals.SPI2,
        esp_hal::spi::master::Config {
            frequency: 20.kHz(),
            mode: SpiMode::Mode0,
            ..esp_hal::spi::master::Config::default()
        },
    )
    .with_sck(sck)
    .with_mosi(mosi)
    .with_miso(miso);

    let spi_device =
        embedded_hal_bus::spi::ExclusiveDevice::new_no_delay(spi, cs).unwrap();

    let interface = pn532::spi::SPIInterface { spi: spi_device };

    let timer = TimerWrapper {
        timer: PeriodicTimer::new(timer0),
    };

    info!("Creating pn532");
    let mut pn532: Pn532<_, _, 32> = Pn532::new(interface, timer);

    info!("Configuring pn532");

    if let Err(e) = pn532.process(
        &Request::sam_configuration(SAMMode::Normal, false),
        0,
        500.millis(),
    ) {
        info!("Could not initialize PN532: {e:?}")
    }

Managed to get it working, I had to use the features = ["msb-spi"] for it to work.

Awesome! Note that on the esp you can set the bit-order
https://docs.rs/esp-hal/latest/esp_hal/spi/master/struct.Config.html


ECG example not working in Core2

It seems ECG example is not working in Core2.
Adjusted Serial lines doesn't work like described.
Is there more modification needed?

Hello @iPsych
I don't have the ECG module, but I think the GPIOs should be changed from 13, 5 to 19, 33.
Eg. try to modify this line:
Serial1.begin(115200,SERIAL_8N1,13,5);
to
Serial1.begin(115200,SERIAL_8N1,19,33);
As a reference - the differences of the M5Stack bus and M5Core2 bus.
Good luck!
Felix

Hello @iPsych
I don't have the ECG module, but I think the GPIOs should be changed from 13, 5 to 19, 33.
Eg. try to modify this line:
Serial1.begin(115200,SERIAL_8N1,13,5);
to
Serial1.begin(115200,SERIAL_8N1,19,33);
As a reference - the differences of the M5Stack bus and M5Core2 bus.
Good luck!
Felix

@felmue
Thanks.
It was the problem! The correct pin allows to run the example in Core2.

@felmue
Thanks.
It was the problem! The correct pin allows to run the example in Core2.


Add support for Fedora 40

This issue is created to track progress for the work to enable Fedora 40 support for .NET 8.0, .NET 7.0 and .NET 6.0
Product and Test updates

[ ] [All teams] Do a compatibility check for the product with the new OS
[ ] [CoreCLR/CoreFX] Runtime / RID Support update
[ ] [Infra] Ensure that the correct Docker images used by teams are built in the dotnet-buildtools-prereqs (if applicable)
[ ] [Infra] Replace docker tags used in builds across repos and branches
[ ] [CLI team] Update CI legs to latest updated Dockerfile
[ ] [All teams] Update test infrastructure to support the new version
[x] ~[Acquisition] Add support within nightly repos~
[x] ~[Acquisition] Deploy to master (GA) during next patch release cycle~

Release team:

[x]  Notify .NET Core teams regarding new OS release
[ ] Update the supported OS content on GitHub and marketing sites.

Document updates:

[ ] Add OS prerequisites to the dependencies document
[ ] Update distro install page

@rbhanda Note: Starting with .NET 8.0, the RID graph is frozen. In other words, adding RIDs is currently only needed for 6.0 and 7.0.
For reference, see issue https://github.com/dotnet/runtime/issues/90000 and PRs https://github.com/dotnet/runtime/pull/90297 (which was merged to 8.0 before it was shipped).

The 7.0 runtime PR has been closed for the reasons described in the PR: https://github.com/dotnet/runtime/pull/98079#issuecomment-1934981974
The 6.0 runtime PR has been merged.

Just a note, Fedora 40 just landed! Is 8.0 available for it now?

If you are looking for Fedora-maintained packages (ie, maintained by the Fedora .NET SIG, as opposed to Microsoft built/maintained .NET packages), .NET 6.0 and .NET 8.0 have been available in Fedora repos since 40  entered development.
$  podman run -it fedora:40                                                                                12:14:06 [36/36]
Resolved "fedora" as an alias (/etc/containers/registries.conf.d/000-shortnames.conf)
Trying to pull registry.fedoraproject.org/fedora:40...
Getting image source signatures
Copying blob 454eac4198a0 done   |
Copying config 868a0de675 done   |
Writing manifest to image destination
[root@5cd85d831277 /]# dnf install -y dotnet-sdk-8.0
Fedora 40 - x86_64                                                                                7.4 MB/s |  20 MB     00:02
Fedora 40 openh264 (From Cisco) - x86_64                                                                                2.1 kB/s | 1.8 kB     00:00
Fedora 40 - x86_64 - Updates                                                                                3.6 MB/s | 2.1 MB     00:00
...
Installed:
  aspnetcore-runtime-8.0-8.0.3-1.fc40.x86_64      aspnetcore-targeting-pack-8.0-8.0.3-1.fc40.x86_64         dotnet-apphost-pack-8.0-8.0.3-1.fc40.x86_64
  dotnet-host-8.0.3-1.fc40.x86_64                 dotnet-hostfxr-8.0-8.0.3-1.fc40.x86_64                    dotnet-runtime-8.0-8.0.3-1.fc40.x86_64
  dotnet-sdk-8.0-8.0.103-1.fc40.x86_64            dotnet-targeting-pack-8.0-8.0.3-1.fc40.x86_64             dotnet-templates-8.0-8.0.103-1.fc40.x86_64
  libicu-74.2-1.fc40.x86_64                       netstandard-targeting-pack-2.1-8.0.103-1.fc40.x86_64

Complete!
[root@5cd85d831277 /]# dotnet --info
.NET SDK:
 Version:           8.0.103
 Commit:            6a90b4b4bc
 Workload version:  8.0.100-manifests.e99a2be4

Runtime Environment:
 OS Name:     fedora
 OS Version:  40
 OS Platform: Linux
 RID:         fedora.40-x64
 Base Path:   /usr/lib64/dotnet/sdk/8.0.103/

.NET workloads installed:
 Workload version: 8.0.100-manifests.e99a2be4
There are no installed workloads to display.

Host:
  Version:      8.0.3
  Architecture: x64
  Commit:       9f4b1f5d66

.NET SDKs installed:
  8.0.103 [/usr/lib64/dotnet/sdk]

.NET runtimes installed:
  Microsoft.AspNetCore.App 8.0.3 [/usr/lib64/dotnet/shared/Microsoft.AspNetCore.App]
  Microsoft.NETCore.App 8.0.3 [/usr/lib64/dotnet/shared/Microsoft.NETCore.App]

Other architectures found:
  None

Environment variables:
  Not set

global.json file:
  Not found

Learn more:
  https://aka.ms/dotnet/info

Download .NET:
  https://aka.ms/dotnet/download

Nice! Does Microsoft maintain a first-party .NET fedora package repo?

Yes, it does.
https://packages.microsoft.com/config/fedora/40/
https://packages.microsoft.com/fedora/40/prod/

@rbhanda I have a question regarding the versioning.
As of today(4/26/2024), Microsoft packaged dotnet-8.0 packages on packages.microsoft.com have version number 8.0.4-1. The Fedora 40's dotnet-8.0 packages have version number 8.0.4-1.fc40, and DNF would see Fedora ones newer than Microsoft's ones, is that a desired/expected behavior?
In dotnet --info outputs, Commit ID of the "Host" section are the same, 2d7eea2529. But in the .NET SDK section, Microsoft packaged one is returning version 8.0.204, with commit ID c338c7548c, Fedora's is returning version 8.0.104 with commit ID 034f91fcc0.

@inntran I recommend against any mixing of Fedora-built and Microsoft-built packages of .NET.
You should enable the Microsoft repository, and disable fetching any dotnet packages from Fedora. Or you should disable the Microsoft repository and only use dotnet packages from Fedora. Having both enabled will pull down some packages from each repo - as you discovered - which will result in a broken .NET installation.
We have some steps on how to do that here: https://learn.microsoft.com/en-us/dotnet/core/install/linux-package-mixup?pivots=os-linux-redhat

PR for docs: https://github.com/dotnet/docs/pull/40659

I thought it might help to say if I install .NET 8.0 on Fedora 40 from Microsoft's repository and not the Fedora-maintained repos, I get the following message when running a dotnet command (e.g. dotnet new) :
You must install or update .NET to run this application.

App: /usr/share/dotnet/sdk/8.0.300/dotnet.dll
Architecture: x64
Framework: 'Microsoft.NETCore.App', version '8.0.5' (x64)
.NET location: /usr/share/dotnet/

The following frameworks were found:
  8.0.4 at [/usr/share/dotnet/shared/Microsoft.NETCore.App]

Learn more:
https://aka.ms/dotnet/app-launch-failed

To install missing framework, download:
https://aka.ms/dotnet-core-applaunch?framework=Microsoft.NETCore.App&framework_version=8.0.5&arch=x64&rid=linux-x64&os=fedora.40

@mdx0111  That issue is https://learn.microsoft.com/en-us/dotnet/core/install/linux-package-mixup?pivots=os-linux-redhat again.

@mdx0111 That issue is https://learn.microsoft.com/en-us/dotnet/core/install/linux-package-mixup?pivots=os-linux-redhat again.

@omajid I don't think so as I have excluded Fedora maintained .NET packages altogether.

@mdx0111 Hm. Can you run a sudo dnf upgrade --refresh? I think you might have picked up a newer sdk but not the newer runtime from the Microsoft packages repo.

@mdx0111 Hm. Can you run a sudo dnf upgrade --refresh? I think you might have picked up a newer sdk but not the newer runtime from the Microsoft packages repo.

@omajid Thanks for the help! That's all sorted now.


Show 'providers' information

Prerequisites
Put an x into the box(es) that apply:

[ ] This pull request fixes a bug.
[x] This pull request adds a feature.
[ ] This pull request enhances existing functionality.
[x] This pull request introduces breaking change.

For more information, see the Contributing Guide.
Description
This PR adds  new functionality to show providers information. This was originally added in #113 by @moatra which we decided to introduce it in its own PR for the sake of cleaner history.
Issues Resolved
List any existing issues this pull request resolves.
Checklist
Put an x into all boxes that apply:

[ ] I have read the Contributing Guidelines.

Tests

[x] I have added tests to cover my changes.
[x] All tests pass when I run make test.

Documentation

[ ] My change requires a change to the documentation.
[ ] I have updated the documentation accordingly.

Code Style

[ ] My code follows the code style of this project.

@khos2ow should we display provider information optionally?

I think after a little while showing provider information will become mainstream, and instead of opt-in approach I had thought to add new flags for opt-out approach, --no-providers, --no-inputs, --no-outputs. What do you think?

@khos2ow I like that approach!

Guys, how is this supposed to work ? I guess it will show the same output as Providers Requirements section from terraform-config-inspect ? Or terraform providers ? Can you provide some examples based on the test data ?

@crisp2u it looks for required_providers but it's not the only way to look for the providers, we're also looking for all the managed and data resource to discover the providers (module.go#134).
Also you can find the generated content here based on our example.


Weirdness with filter.

I am getting weird results with the filter parameter:
sauron% curl -L "https://script.google.com/macros/s/AKfycbwz3mAVQlt4OGxorkKPiyx0PCaQSY0T0RJ1YItca60RGBlt5yHw45XeLn8sHu9DpCymRQ/exec?url=/api/officials&limit=0&apiKey=d08Low0RV7yL&filter=lower(office)+contains+'selectboard'"
[]sauron% curl -L "https://script.google.com/macros/s/AKfycbwz3mAVQlt4OGxorkKPiyPCaQSY0T0RJ1YItca60RGBlt5yHw45XeLn8sHu9DpCymRQ/exec?url=/api/officials&limit=0&apiKey=d08Low0RV7yL&filter=lower(office)+contains+'selec'"
[{"office":"Selectboard","name":"Laurie DiDonato","term":"2024","electedp":true,"index":29},{"office":"Selectboard","name":"Gillian Budine","term":"2022","electedp":true,"index":30},{"office":"Selectboard","name":"Dan Keller","term":"2023","electedp":true,"index":31},{"office":"Selectboard Clerk","name":"Joy Gorzocoski","term":"2020","electedp":false,"index":168},{"office":"Selectboard Clerk","name":"Liam DiDonato","term":"2020","electedp":false,"index":169}]
sauron% curl -L "https://script.google.com/macros/s/AKfycbwz3mAVQlt4OGxorkKPiyPCaQSY0T0RJ1YItca60RGBlt5yHw45XeLn8sHu9DpCymRQ/exec?url=/api/officials&limit=0&apiKey=d08Low0RV7yL&filter=lower(office)+contains+'selec'"
[{"office":"Selectboard","name":"Laurie DiDonato","term":"2024","electedp":true,"index":29},{"office":"Selectboard","name":"Gillian Budine","term":"2022","electedp":true,"index":30},{"office":"Selectboard","name":"Dan Keller","term":"2023","electedp":true,"index":31},{"office":"Selectboard Clerk","name":"Joy Gorzocoski","term":"2020","electedp":false,"index":168},{"office":"Selectboard Clerk","name":"Liam DiDonato","term":"2020","electedp":false,"index":169}]
sauron% curl -L "PCaQSY0T0RJ1YItca60RGBlt5yHw45XeLn8sHu9DpCymRQ/exec?url=/api/officials&limit=0&apiKey=d08Low0RV7yL&filter=lower(office)+contains+'select'"
[]
I want to select all Selectboard members, but it looks like lower('Selectboard') contains 'selec', but that lower('Selectboard') does NOT contain 'select'.  Huh?  What is going on here?

I think you did not encode the condition correctly. It does not support function in query condition so you should try Selectboard contains 'select' instead of lower('Selectboard') contains 'selec',

I tried various combinations, which gave results that did not make sense.
Literally exact equality did not work, but the lower() sort of worked, but
weirdly, but only for one partitular case.  lower('Selectboard') contains
'selec' worked. but lower('Selectboard') contain 'select' did not, but
lower('Selectboard') contains 'electboard' did.  This does not make any
logical sense -- 'Selectboard' only sometimes contains a 't'! This is
nonsense.  Unless 't' is some kind a strange cat in a box that might be both
dead and alive!  Huh?  The problem was only with the 't' in 'Selectboard'.
Other elements of other records generally worked just fine.  And no, there are
no 'hidden' UTF-8 characters.  The spreadsheet was created from an ASCII CSV
file.  Unless Google Sheets import from ASCII CSV files is funky in some odd
way.
At this point I have totally given up on Google Sheets.  I will be looking for
some other way of dealing with this.  Maybe a dedicated PHP coded webpage
using a SQL database.  Maybe Zoho's cloud spreadsheet. Maybe something else
(AWS?).
At Sun, 17 Apr 2022 17:39:38 -0700 gslack-app/sheet-api @.***> wrote:

I think you did not encode the condition correctly. It does not support function in query condition so you should try Selectboard contains 'select' instead of lower('Selectboard') contains 'selec',

--
Robert Heller             -- Cell:<PHONE_NUMBER> GV:<PHONE_NUMBER>
Deepwoods Software        -- Custom Software Services
http://www.deepsoft.com/  -- Linux Administration Services
@.***       -- Webhosting Services


Fix bug with file chooser, and modify behaviour of insurance package

Fix the bug of the file chooser not working for non-Windows users, and modify the relationship between insurance package and person, such that a package in use by a person cannot be deleted

Looks great yiheng thanks for fixing the filechooser for mac users and adding more constraints for the insurance packages!


Select and introduce a license

Currently considering MIT license for the software elements and OSHWA for the hardware (see https://www.oshwa.org/faq/ and https://habr.com/en/post/243091/)


Use TS to compile the code

making use of TSC to compile to ES2018 (Node 12+)
remove babel from build (but needed for tests)
fix all noImplicityAny errors
update apify-shared version #570
manually type untyped external apify dependencies
update typescript_fixes
change npm clean command to remove generated types as well
types and build are one step now
pin @types/node to 12
standardized parameter types naming (Number -> number, String -> string, etc) based on both https://github.com/google/closure-compiler/wiki/Generic-Types and https://jsdoc.app/tags-type.html so it should be lowercase in general, the only exception is Object, which behaves differently in TS. a @returns {Object} is the literal global Object (with .values, .prototype.hasOwnProperty, etc). Binding a parameter to {Object} means object instances, but binding as return doesn't. to generate any types, can use either {object} (lowercase) or {*} as per JSDocs, but it's less legible
TS coders usually use strict: true,  strictNullChecks: true, alwaysStrict: true and noImplicitAny: true as tsconfig.json. Those configs make everything that is not typed (read: generics) or any to need a typecast or set the variable either to any or to the expected type. for example:

await Apify.getInput()

returns a Promise<any>. If you want to use it in TS, you need to provide a type like
const input: Schema = await Apify.getInput()

from now on, the proper way to do it is:
const input = await Apify.getInput<Schema>()

since getInput is nullable, the input variable will be Schema | null, which you can't use until you check for it's truthiness, as seen below, if you don't if (!input it will consider as null even through typeof input !== 'object' is true
before:

after:

Even though the Lint&Docs are passing, JSDOC is erroring in nested array types using []. gonna try to fix that

that's type safety, beyond "auto complete". when you create a crawler with a generic, it will cascade down in every function that uses userData  on request and userData on session. if you don't provide these, like I explained above, every "userData" will be any, and that doesn't play well with strict options enabled, you would need to provide typecasts everywhere.
you can try this gist for yourself, created a minimal demo https://gist.github.com/pocesar/d4780c3dd3cc2e30d2ad8a2ce28f04e5 if you have vscode, hover over each property (even the de-structured ones)
so, when you define a top level generic (like in the crawler), everything inside also automatically becomes type-safe (and don't fail with strict options on).
if you think the docs need a post-processing as well, I can try and post-process them to remove the generic parts, since it's most useful for code editors / IDEs. Jsdoc, by itself, is a huge hassle to create proper type-safe TS typings, but on plain JS, the code just works without touching generics (but you can provide type-safe in JS using  (in test.js in that gist).
it adds a lot of clutter when add @type using JSDoc, but allows plain JS to be typesafe as well, mostly against typos and mismatching types (numbers vs strings vs objects), and for collaborators that are having to dealing with other peoples code, they don't need to dig everything by themselves, if they have an editor that understand generics.

Ok, got it now with the example. Basically, you need to inject types into the system and you do this by defining the injectable types in JSDoc as templates and then defining the actual types in your actor, passing them down to the existing templates.
Yeah, this is useful I guess, but as you said, it makes the docs really hard to read. Would be great if we could either post-process it out or figure out a different way to inject the generics.

yup, the variables become self documented, so it's easier to maintain (at least by my years working with TS)
okay, I'll do some post processing on the generated docs then

Close in favor of #603


Issue 2: Figure out how to add issues to minibookdown repository

https://github.com/AEG15/minibookdown

moving them to right repository

moving them to right repository


Add bundle-cleanup target

Add bundle-cleanup target to remove the bundle installed via bundle-run

/lgtm


Fix method name in client cancellation send

The server registers a notification handler on CancelledNotificationSchema, but is never called on client cancellation because of a mismatch in the method name. This fixes that mismatch.
Motivation and Context
Cancellation between server <-> client implementations does not seem to function correctly. There's no propagation of an abort signal from the client to the server.
How Has This Been Tested?
I made this change in the dependency tree of a local application and saw that the server signal is properly canceled after the change.
Breaking Changes

Types of changes

[x] Bug fix (non-breaking change which fixes an issue)
[ ] New feature (non-breaking change which adds functionality)
[ ] Breaking change (fix or feature that would cause existing functionality to change)
[ ] Documentation update

Checklist

[x] I have read the MCP Documentation
[x] My code follows the repository's style guidelines
[ ] New and existing tests pass locally
[ ] I have added appropriate error handling
[ ] I have added or updated documentation as needed

Additional context

Very good catch, thank you!


Unknown stack overflow

Version: rust-analyzer-0.2.344
Os: Manjaro Mikah 20.1.1
Encountered this stack overflow today:
thread '' has overflowed its stack
fatal runtime error: stack overflow
[Info  - 3:42:50 PM] Connection to server got closed. Server will restart.
[Error - 3:42:50 PM] Request textDocument/documentHighlight failed.
Error: Connection got disposed.
at Object.dispose (/home/jesper/.vscode/extensions/matklad.rust-analyzer-0.2.344/out/src/main.js:4311:27)
at Object.dispose (/home/jesper/.vscode/extensions/matklad.rust-analyzer-0.2.344/out/src/main.js:9337:35)
at LanguageClient.handleConnectionClosed (/home/jesper/.vscode/extensions/matklad.rust-analyzer-0.2.344/out/src/main.js:11578:42)
at LanguageClient.handleConnectionClosed (/home/jesper/.vscode/extensions/matklad.rust-analyzer-0.2.344/out/src/main.js:12900:15)
at closeHandler (/home/jesper/.vscode/extensions/matklad.rust-analyzer-0.2.344/out/src/main.js:11565:18)
at CallbackList.invoke (/home/jesper/.vscode/extensions/matklad.rust-analyzer-0.2.344/out/src/main.js:2347:39)
at Emitter.fire (/home/jesper/.vscode/extensions/matklad.rust-analyzer-0.2.344/out/src/main.js:2409:36)
at closeHandler (/home/jesper/.vscode/extensions/matklad.rust-analyzer-0.2.344/out/src/main.js:3558:26)
at CallbackList.invoke (/home/jesper/.vscode/extensions/matklad.rust-analyzer-0.2.344/out/src/main.js:2347:39)
at Emitter.fire (/home/jesper/.vscode/extensions/matklad.rust-analyzer-0.2.344/out/src/main.js:2409:36)
at StreamMessageReader.fireClose (/home/jesper/.vscode/extensions/matklad.rust-analyzer-0.2.344/out/src/main.js:2560:27)
at Socket. (/home/jesper/.vscode/extensions/matklad.rust-analyzer-0.2.344/out/src/main.js:2644:42)
at Socket.emit (events.js:228:7)
at Pipe. (net.js:664:12)

Are you on stable? If yes then this is probably the same stack overflow which was fixed in https://github.com/rust-analyzer/rust-analyzer/pull/6222

It was downloaded through vs-code so I think that is stable. Closing as it already fixed. Thanks!


data error

this is the error i got every time i run it.
i don't know what to do.please tell me what to do.

pip install chatterbot-corpus
This will install the corpus which is a separate package.

thank you very much for your help

what should i do now.please help me

by the way i fix that problem.sorry for that. now i got a new problem.i don't know how to fix this one.

please help me with this problem.

bot.train(data)
should be
trainer.train(data)

after trainer.train(data) this shows

Tell me something.I am giving you the file. Tell me where i did wrong.
chatbot.zip
Please help.I need your help fast.Please do something.

Hello @sadmansad2003 ,
Just realized what you did here.
Please check it in the docs.
You don't have to read the file manually, let the trainer do that for you.
replace this part:
for files in os.listdir('data/english/'):
 data = open('data/english/' + files , 'r').readlines()
 trainer.train(data)

With this:
trainer.train(
    "./data/english/"
)

and it should be fine. :)

@Orfeous thanks you very much.my problem is solve.


Refactoring code  / a bit of cleanup

I starting to refactor the app, before it start being a mess :)

For me all presets are broken except for the new one "Video Stream Service" that works like before.
I have a glitchy video or nothing with others.

@omouren. I haven't payed attention to other preset btw, as It's a major rework of the streaming internals, it may have broke some stuff... Will have a deeper look ^^


Feature request: support PHP

Skiffa's philosophy is, of course, to provide clients in multiple languages. Typescript is supported (yeah!). My second request would be a PHP client. We have many customers who use WordPress, and we also develop integrations for that platform.

We will most definitely support PHP!
The real question is, when?
A lot of people in the world use PHP, it is one of the largest languages so that makes the priority for this high. Also, if you require it that also increases prio!

I have been getting funding to research calling foreign code in many languages. Would love to use WIT for it, but we need a faster solution. This sill be a first step in supporting many languages, starting with PHP.
Hang in there, this is on our radar!


[path_provider] Add missing pluginClass: none to path_provider_windows

Description
Older versions of Flutter (still supported by path_provider) need a
'pluginClass: none' to avoid "Invalid plugin specification" errors
when parsing a Dart-only desktop plugin like this one.
Related Issues
Fixes https://github.com/flutter/flutter/issues/66158
Checklist
Before you create this PR confirm that it meets all requirements listed below by checking the relevant checkboxes ([x]). This will ensure a smooth and quick review process.

[x] I read the Contributor Guide and followed the process outlined there for submitting PRs.
[x] My PR includes unit or integration tests for all changed/updated/fixed behaviors (See Contributor Guide).
[x] All existing and new tests are passing.
[x] I updated/added relevant documentation (doc comments with ///).
[x] The analyzer (flutter analyze) does not report any problems on my PR.
[x] I read and followed the Flutter Style Guide.
[x] The title of the PR starts with the name of the plugin surrounded by square brackets, e.g. [shared_preferences]
[x] I updated pubspec.yaml with an appropriate new version according to the pub versioning philosophy.
[ ] I updated CHANGELOG.md to add a description of the change.
[ ] I signed the CLA.
[ ] I am willing to follow-up on review comments in a timely manner.

Breaking Change
Does your PR require plugin users to manually update their apps to accommodate your change?

[ ] Yes, this is a breaking change (please indicate a breaking change in CHANGELOG.md and increment major revision).
[x] No, this is not a breaking change.

Adding a bunch of reviewers so whoever can get to it first can approve.
I don't understand how CI on the endorsement PR passed if stable still requires the pluginClass: none workaround.

Ah, I think this only happens for people who haven't updated to the current stable. 1.20 shouldn't need this. However, path_provider doesn't require 1.20+ currently, so this should still be added (so that the last version that claims to support older versions isn't broken on those versions).

I think we can just make path_provider to require 1.20+ .

I think we can just make path_provider to require 1.20+ .

We could do that later, but if we don't push this first then the last published path_provider that supports 1.17 will be broken for 1.17, which is not a good situation to permanently leave the ecosystem in.


RAS-873: Show supplementary dataset ID in Rops collection exercise

What and why?
Adds a panel to notify a Response Operations user that this collection exercise has pre populated data linked with it.
How to test?

Deploy this PR to your environment
Ensure that https://github.com/ONSdigital/rm-collection-exercise-service/pull/318 is either merged or deploy it to your environment
Set up a collection exercise in Response Operations (only period ID is needed)
Place a pubsub message using and replacing your namespace, survey ID and period ID:

gcloud pubsub topics publish projects/ras-rm-dev/topics/supplementary-data-service-[your namespace] --message='{
    "survey_id": [your survey ID],
    "period_id": [your period ID],
    "form_types": [
       "0017",
       "0123",
       "0001"
      ],
    "title": "A dataset version 4 for survey 2012 period 2013",
    "sds_published_at": "2023-07-17T14:46:36Z",
    "total_reporting_units": 2,
    "schema_version": "v1.0.0",
    "sds_dataset_version": 4,
    "filename": "373d9a77-2ee5-4c1f-a6dd-8d07b0ea9793.json",
    "dataset_id": "b9a87999-fcc0-4085-979f-06390fb5dddd"
}'

Refresh the collection exercise in Response Operations, now a panel saying Pre-Populated data is available for this sample should appear at the top (in line with the design https://www.figma.com/file/uUb6GDGbgYVILiK5wP9wqi/CE-Reporting-period-page?type=design&node-id=2220-73919&mode=design)

Trello
RAS-873

/deploy wilkia


Feat(renderHTML): add theme-color meta tag

Feat(renderHTML): add theme-color meta tag

Coverage remained the same at 100.0% when pulling 578041bddfad594eb033e1415d5db2fc00fa7033 on feature/theme-color into 604a13f48b63e59572cc5da45af2e3e11103ae1b on master.


Tether doesn't update properly when target parent has overflow-y: auto;

I've encountered an issue with Tether where the position of the tethered element isn't updated properly when the parent of the target element has the CSS style overflow-y: auto. The initial position of the element is correct, but when the page is scrolled, the position of the element doesn't move alongside of the target.
If this one line of CSS is removed, things work correctly again. In addition, if there is a manual Tether.position() call made, the element is moved to the proper location.
I haven't had time to make a minimal repro of the bug, my apologies. I thought I'd check if there are any initial things I could try out to get things working properly.

+1 Faced the same issue, using overflow-y: auto.

Managed to make it work. Be sure that your scrollable container has one of the styles for position: relative, absolute or fixed, and then tether will manage to detect the parent.

I'm having a similar issue. When I put position:relative in the parent container, Tether moves the elements outside the container.

Any feedback on this? I also have similar issue, but position does not help :(


Rust attribute changes are not ideally associated

Using the indexmap repo, I tried the following command:
GIT_EXTERNAL_DIFF=difftastic git show --ext-diff 49d430808ced6d1824ec15d621acd6b0e8367c19

and got this output near the end:

Notice how the #[test] attribute is interpreted, where the following one is considered to be an insertion, instead of the one that's on the new function. This kind of thing is very common with line-based diffs, although plain git show actually does get this right!

Yeah, this is sometimes called a "slider", and difftastic isn't completely immune.
I have been thinking about trying to nudge the diff logic to avoid blank lines, but it might increase complexity. The best solution for Rust here is probably to improve the tree-sitter parser to include the attribute with the function definition.

I'm seeing the exact slider behavior described above, in Difftastic 0.31.0, in my codebase (redacting the test function body, private and probably not relevant):

However, it does get the above indexmap example right:

Not sure what the difference is. Maybe these just fall on either side of some heuristic threshold?


Resolve CONFIGFile issue related to Individual Services

[x] Take the initial CONFIGFile
[x] For the provided individual service , check weather an operation server is available.
[x] If there is a missing operation-server , create one.
[x] Validate the JSON file
[ ] Also provide details about the missing operation-server as a comment in the issue.
[ ] Read Processing an Issue
[ ] Read Creating a Commit
[ ] Process the Issue you created and commit the changes
[ ] Read Completing an Issue and creating a Merge Request
[ ] Push your branch containing your contribution and add a CodeOwner as reviewer
[ ] Confirm that the CodeOwner merged your contribution
[ ] Close this issue

There are three IndividualServices present in the YAML file:
/v1/list-applications-abbreviation:  listApplications
/v1/bequeath-your-data-and-die:  bequeathYourDataAndDie
/v1/start-application-in-generic-representation:  startApplicationInGenericRepresentation
However I don't know how to check if there is an an operation (OAM) server available for each of this individual services.

Hello and thanks very much for the pointers.
I fixed the operation name in the config file from "/v1/list-application-abbreviation" to "/v1/list-applications-abbreviation" (added the "s").

Thanks for fixing the issue.
I approved and merged the PullRequest , so closing this issue.


fix(material-experimental/mdc-slider): add strong focus indication

Fixes that the MDC-based slider didn't have a strong focus indicator.

@zelliott any change a UX person from your side would have an opinion on this? I'm not sure if you see much slider usage?

@zelliott any chance a UX person from your side would have an opinion on this?

I think our UX preferred for it to be on the thumb, even on the non-MDC slider. They didn't feel strongly though, and it was easier to place it on the entire slider, so that's what I ended up doing (plus slider usage is low in Pantheon). Plus the SR virtual cursor matched the Material focus indicator that way.
Given the MDC slider can have two thumbs, as Miles mentioned above, I'd guess UX would double-down on their original preference. A strong focus indicator on the entire slider makes less sense on a two-thumb range slider... it's not clear at all which thumb you're actually sending input to. It's too bad that the slider's visually hidden input doesn't have the same bounding box as the actual thumb... that way you'd avoid the SR virtual cursor being different from the Material focus indicator.

Yeah, we tried to drive the thumbs with the native thumbs and couldn't make it work cross-browser, there should be a comment somewhere in the code that explains why.
+1 to having the indicator on the thumb.

I've moved the focus indicator to the thumb as discussed.


Skipping training since max_steps has already saved.

I tried using the same model on a custom dataset. But I got the above error. Do you know how I can get around it?

When you trained the initial model, a checkpoint file was generated and saved in the output directory. You're seeing that error because the number of steps completed in training is equal or greater than the 'max_steps' parameter in BERT_NER.py#628:
estimator.train(input_fn=train_input_fn, max_steps=num_train_steps)
The model is loading the checkpoint and seeing that max_steps has already been completed.
If you want to train on your dataset, increase num_train_steps. You can also re-train the model by deleting the checkpoint files generated in the output directory. If you just want to evaluate the model on your custom data without training, use FLAGS.do_eval or FLAGS.do_predict instead of FLAGS.do_train.


import causing socket timeouts and sometimes OOM kills

the import function seems to be a bit flakey somehow, using up too much memory and causing the socket to wait too long to write
possible solutions in mind:

write the import file to disk first and then process it
run import function with profiling on and examine which exact part of the code is causing memory usage to spiral out of control

it is likely that the two things are connected somehow, probably loops where new objects are being allocated and though they are kinda out of scope the GC is not recognising this
probably other things that might fix it:

breaking down the import function into one or more separate functions so the compiler gets the scope hinting clearly and GCs correctly

firstly, the timeout seems to be something else, it is almost precisely 7 seconds which is a context timeout default implemented in ws/client.go
can't find the read timeout setting so there needs to be some other thing done to stop it timing out the socket


Ollie: Watch ijam3ana.com

Ollie requests the watch of the watch_keyword ijam3ana\.com. See the MS search here and the Stack Exchange search in text, in URLs, and in code.

ijam3ana\.com has been seen in 1 true positive, 0 false positives, and 0 NAAs.

ijam3ana\.com has been seen in 1 true positive, 0 false positives, and 0 NAAs.

Approved by Jeff Schaller in Charcoal HQ

Approved by Jeff Schaller in Charcoal HQ


Define lint npm script

Create npm run lint script (and fix one linting issue)
Add syntax highlighting for code blocks in README

Thanks for your contribution!
@all-contributors please add @noahbrenner for code, docs


NSSecureCoding doesn't seem to work

Windows version: Windows 10 Education
Visual studio version: Visual studio Enterprise 2015
Build in 32-bits
I tested the OBJCXX-Test test to see if the NSSecureCoding protocol worked, but when I use the NSKeyedArchiver::archivedDataWithRootObject method then I printed the binary data, the data doesn't seem to be encoded.
Any Idea ?
Thanks :),
Heru.

Well, difficult to tell without seeing your code or the encoded data.
Please provide more info.

The only code I use is the one which is provided from the OBJCXX-Test repository, the Foo class on Foo.cpp file.
I just printed the bplist made by the NS::KeyedArchiver::archivedDataWithRootObject method:
`
    NS::Log( "%@", static_cast< id >( f1.text() ) );
    f1.text( "hello, universe" );
    NS::Log( "%@", static_cast< id >( f1.text() ) );

    d = NS::KeyedArchiver::archivedDataWithRootObject( f1 );
    // Just added a pretty printer here to see what is inside 'd' like: PrettyPrint(d.bytes(), d.length());
    NS::Log( "%@", static_cast< id >( d ) );

    f2 = NS::KeyedUnarchiver::unarchiveObjectWithData( d );

    NS::Log( "%@", static_cast< id >( f2.text() ) );

`
And it's like the NSSecureEncoding has not done its job because the data is has not been encoded :( !

I don't see any issue in the latest version.

What do you mean by «the data is has not been encoded»?
Is the data empty?

The data is unarchived successfully but inside the bplist generated by NSKeyedArchiver, the string "hello, universe" is not encoded.
I mean, when I binary print the content of the variable d, I can see the string "hello, universe" but I think it should be encoded thanks to the protocol "NSSecureEncoding" and the instance method "encodeWithCoder:" so we shouldn't be able to see this string clearly, but on another format like, for example: "bTCk1J32S+Syd4d87gciwy==".
Sorry if I'm not clear when I'm talking, I hope you understood what I'm talking about :) !

Well, it looks like you don't understand what NSSecureCoding is about.
It has nothing to do with data representation, or encryption.
It's simply a contract between you and the archiver.
It simply tells the archiver you are going to decode your properties in a safe manner.
Implementing NSSecureCoding will have zero impact on the generated data, and this is the normal/expected behaviour.
You can read more on Apple's website:
https://developer.apple.com/documentation/foundation/nssecurecoding
I'm closing this issue, as the code is behaving as expected regarding NSSecureCoding.
Feel free to open another one if you have implementation issues.


Names can have spaces after all

I'm currently writing an objects.inv parser in non-Python and stumbled into something that you might be interested in: contrary to https://sphobjinv.readthedocs.io/en/stable/syntax.html, the name field can indeed contain spaces.
I've encountered it in my very own project, that has the following line:
dict classes std:term -1 glossary.html#term-dict-classes -

I tried loading https://www.attrs.org/en/stable/objects.inv with sphobjinv and it seems to silently ignore these entries.
Maybe you can just steal their regex.

Y'know, I know I looked at that regex when I put the project together, and I must've gotten tripped up by a canonical Black Swan -- I looked through a bunch of inventories and didn't see any names with spaces, and thought about it for a while and couldn't think of any examples where it would have spaces. I think I then assumed that the Sphinx devs were just being over-cautious for a case that shouldn't occur, and so coded sphobjinv to only accept entries with spaces.  I use re.finditer to parse the lines of object data, which indeed will just ignore such entries, as you observed.
You reported this at a good time -- I'm just at the cusp of a v2.1 release.  As part of addressing #147, I relaxed the constraints on the priority field, to allow non-integer and non-numeric values. BUT. Obviously, the -?\d+ will only match integers, so I need to rip that back out before any production release.
This means that in addition to a fix here, I need to improve my test suite, at minimum to compare inventory data not run through sphobjinv,Inventory with the data that makes it into an Inventory instance.
Thanks very much for the report!

Yep. Biiiiiiig bug.

I attract those kind of things, you know. ;)

Hehe.
 Woops.


Error logging improvements

Summary
Currently, if there is an error within the module, the error output is not always enough to figure out what went wrong as only the error message line is printed and then silently eaten in facter, making it hard to debug issues.
Dev info:

Error handling spot
Change of the error line to this fixes majority of the UX:

-      warn $!
+      warn "Conjur token retrieval failure: " + $!.full_message(highlight: true, order: :top)

Steps to Reproduce
Steps to reproduce the behavior:

Setup puppet with a clean Windows host ready (don't run agent yet)
Setup conjur HFTs
Configure all relevant Conjur facts but leave one out
Run the agent on the node

Expected Results
Well formed and descriptive errors
Actual Results (including error logs, if applicable)
Often obscure one-line error messages
Reproducible

[x] Always
[ ] Sometimes
[ ] Non-Reproducible

Version/Tag number
Tested on Puppet 6 and pre-3.0.0 version but this error would be visible on puppet 5 and any older version as well probably.
Environment setup
Puppet Master: Docker-compose, v6
Puppet Agent: Windows 2012r2 VM in VirtualBox
Conjur Master: Docker-compose, v5
Additional Information
N/A

One thing we want to make sure we understand is the UX when someone invokes conjur::secret but doesn't wrap it with Deferred - we don't support this flow, so there should be a clear error to help the user recover from this.

Original issue is no longer valid as we do not use Facter anymore. I'll split out the other issue (skipping Deferred UX) into its own issue though. Closing.


verify the wrongly spelled "aquisition" is not appearning anywhere in the product

verify the wrongly spelled "aquisition" is not appearning anywhere in the product, if so cleanup appropriately. It should be Acquisition.
earth_enterprise/src/fusion/fusionui/AssetProperties.cpp
earth_enterprise/src/fusion/fusionui/imageproductbase.ui
earth_enterprise/src/fusion/fusionui/terrainproductbase.ui
earth_enterprise/src/fusion/fusionui/vectorproductbase.ui
earth_enterprise/src/fusion/fusionui/rasterimportbase.ui

In the title of this ticket, it should be "appearing" :-)


Markdig.Prism support

I'd like the option to use Markdown.Prism instead of the default syntax highlighting, mainly because Prism.js can be dark themed (and supporting more languages is nice too).

I'll look into adding this.
You should be able to use Prism.js directly by using the --highlighter option.

I'll look into adding this.
You should be able to use Prism.js directly by using the --highlighter option.

Didn't work. I got this mess: https://imgur.com/6yt3lYn
Got the Prism.js file from here: https://prismjs.com/download.html#themes=prism-dark&languages=markup+css+clike+javascript

I created a file prismjs-cdn.inc and added the following lines to it:
<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/prism/1.24.1/themes/prism-dark.min.css">
<script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.24.1/components/prism-core.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.24.1/plugins/autoloader/prism-autoloader.min.js"></script>

I then call md2html with the --highlighter prismjs-cdn.inc

I also downloaded the css and js from the PrismJS site. I created a file prismjs.inc and copied the contents of the downloaded css into it between  tags and copied the contents of the js file into it between  tags.
I then call md2html with the --highlighter prismjs.inc

BTW: currently working on changes that will make dealing with this scenario cleaner. I should be done by this weekend.
You'll be able to add the files you downloaded and they'll be wrapped with the appropriate tags. In this case, you'll call md2html with --style prism.css --script prism.js --custom-highlighter. The --custom-highlighter will keep the default HighlightJS from being included in the HTML file.


Url Bug

Hi just got a bug in the codes. It doesnt show urls.
Original tweet: https://twitter.com/iAmBhawaniGarg/status/1505774634440204288
Photo generated from twite: https://i.imgur.com/BzgvkZb.png
You can see it has removed the URL from the original tweet.

Update in this status i have entered 2 urls: https://twitter.com/iAmBhawaniGarg/status/1505779486306213888
But twite showing the first one only.

Fix df3f9f7628d79b0b866472d79b61184a4e37cb40


request_id is not work

Describe the bug
I want to write a simple chatpgt interaction program that can record the history of conversations each time chatgpt talks to the user. According to the suggestion on the web, when chatgpt returns the result, I need to get the request_id of it and pass it to the next conversation. But when I do this, it doesn't work
Here is the result of the run:

To Reproduce
just run the following code 👇
Code snippets
this is my demo：

import openai
openai.api_key = "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"

contents = [
    "hello, my name is todo",
    "do you know my name in this session"
]
id = None
for content in contents:
    chat = openai.ChatCompletion.create(
            model="gpt-3.5-turbo",
            messages=[
                {"role": "user", "content": content}
            ],
            user = "user0001",
            request_id = id
        )
    message = chat.choices[0].message.content
    id = chat.id
    print("message: ", message)

### OS

Linux team317 <IP_ADDRESS>-microsoft-standard-WSL2

### Python version

python v3.10

### Library version

openai-python 0.27.2

The @try-agaaain, thanks for writing in.
Couple of things:

Never post api key in a repo like this. I would strongly suggest you rotate it if you haven't already
I don't think request_id is a param we had for this API. Where are you seeing that we support that?

Sorry, I will not expose my api key casually.
I found that the create method of ChatCompletion class will calls super().create(*args, **kwargs), where the super class is EngineAPIResource, and the parameters of this super create method are as follows:
    @classmethod
    def create(
        cls.
        api_key=None.
        api_base=None.
        api_type=None.
        request_id=None.
        api_version=None.
        organization=None.
        **params.
    ).

One of the parameters is request_id, which I mistakenly thought was a supported parameter.

If I want to have a continuous conversation via api, is there a more appropriate way to do it?

Ah, interesting. Lemme go look into that request_id field. It's not going to do what you want unfortunately but it would be good for us to have more documentation around the field to avoid confusion
If you want to have a continuous conversation with our models, you'll want to submit all of the previous interactions in the conversation. Our APIs do not currently have a method of retaining the state of a conversation.

Thank you for your answer.


Refactor sg-core

I am tracking changes to STO for the sg-core here, mostly just so that I can run the CI on the changes without having to build everything myself. Most likely this will not contain any changes.

/runtest

/runtest

/runtest

/runtest

/runtest

/runtest

/runtest

/runtest

I decided to put my updates to the performance test here


Fix broken find/replace across project

An accidental find/replace across the entire project seems to have caused a few mistakes in the LICENSE file.
Addresses https://github.com/ampproject/amphtml/issues/16272

@nainar – to review.

 Thank you for your submission! We really appreciate it. Like many open source projects, we ask that you sign our Contributor License Agreement before we can accept your contribution.You have signed the CLA already but the status is still pending? Let us recheck it.