Tag: Semantics

ubuntu – Who am I? Semantics of a sudoers user

I own a server (Ubuntu), where I am the only sudoers user (and usually the only user at all). So, my question is as simple as it sounds: if I am not the root user, but I am a sudoers user, am I actually root? Because in practical means, if someone cracks my password, an attacker can act as root. Therefore, if my account is compromissed, root is compromissed.

So, for example, when installing new services through docker containers (the case I’m dealing with right now), should make container folders belongs to me or root? Because making some folder is owned by root is actually very inconvenient (depending on the x or r flags, I could have no tab-completion or won’t be able to cd or sudo cd because cd is a built-in not a command, etc), without, I think, any gain in security since I have super powers anyway.

In short, what is my role in the system? Maybe this question seems stupid but I have had a hard time trying to balance convenience and security and I haven’t found a satisfying answer so far.

Or maybe the key of the question it’s just my inability to properly analize the security risks I’m exposed to, that brings me to not knowing, for security, what restrictions to strength, and for convenience, what restrictions to relax.

Proof of the small-step semantics property

I am trying to solve Exercise 2.20 from the book "Semantics with Applications" by Nielson & Nielson. The request is as follows:

Exercise 2.20 Suppose (S1; S2, s) => * (S2, s & # 39;). Show that is Not necessarily the case that (S1, s) => * s & # 39 ;.

I suppose the evidence should use induction for the length of the derivative sequence, but I don't even know where to start.

I add the table here that defines the semantics used.

s.s.s. for the language During

Semantics – naming convention with non-class abstraction oriented languages

Dealing with naming conventions for non-class abstraction oriented languages ​​such as C, Rust, Go etc. Class abstraction patterns hide the composition model and avoid repetition when you use it, and ensure a clean display. That it is different without abstraction.

Here is a use case for comparison: Example with class abstraction language 

# (python pseudo code)
class ContentFile:
   contents = Content
   file = File

class TemplateContentFile(ContentFile):
   template = Template

templateContentFile = TemplateContentFile()

Now if I got that (contents) of (templateContentFilewe have to writetemplateContentFile.contents) and we forgot (ContentFile) Abstraction.

Otherwise with classless language of abstraction

// (rust pseudo code)
struct ContentFile {
    contents: String
    file: File
}

struct TemplateContentFile {
    content_file: ContentFile,
    template: Template
}

let template_content_file = TemplateContentFile::new();

Now if I got that (contents) of (template_content_filewe have to writetemplate_content_file.content_file.contents). It's a bit sad with (ContentFileaesthetically speaking:

I am not talking here to achieve this with the implementation method/function or any logic programming, just modeling.

Do you have any advice on how to solve this problem? (maybe also books / articles)

bitwise operators – semantics of the simulation of a 64-bit integer with two 32-bit integers (hi, lo)

I'm working in a system that only supports 32-bit integers. To get a 64-bit unsigned integer, I simply used two 32-bit integers, one of which has the upper 32-bit integers (hi) and the other the lower 32-bit integers (hi ) contains. lo).

I also had to create arithmetic for this (Hi, Lo) structure, but I found it almost impossible to look for existing arithmetic for such structures. The only useful thing I could find is the arithmetic written in openSUSE: https://github.com/openSUSE/checkmedia/blob/master/u64.h

Is there a name for what I am trying to do? (Simulating a double-width integer with a (hi, lo) structure and implementing arithmetic with bitwise operations)

& # 39; arithmetic with arbitrary precision & # 39; is concludeHowever, I do not work with infinite precision.

Machine Learning – Is there a search platform that calculates indexes based on the semantics of words in the text?

I want to save emails for my data science project and search for different terms throughout my collection. The phrases I'm looking for may be different from the actual words, but I should always receive those emails in return.

What is the best platform for this? I need a search database that calculates indexes in an email based on semantics (consider stemmers, synonyms, etc.). An elastic search or cloud search does not work directly.

How effective is the FREETEXT function in SQL Server? Can it serve the purpose?

Apply the HTML5 semantics

Good morning everyone.

I am learning the semantics of html5 and have a knot in my head …

I would like to know if I use the semantics correctly.

  footer {
    position: relative;
    bottom: 0;
    width: 100%;
    background-color: #34495e;
    color: white;
  }

  .m5 {
    margin: 25px 0 25px 0;
  }

  .he1 {
    height: 100px;
  }

  .text-blue {
    color: #016bae;
  }

  .bg-blue {
    background-color: #2980b9;
  }

  .bg-orange {
    background-color: #f39c12;
  }

  footer p {
    height: 13px;
    color: white !important;
  }

  footer p a {
    color: white !important;
  }

  .menu-recursos {
    margin: 0;
    padding: 0;
    list-style-type: none !important;
  }

  .menu-recursos li a {
    position: relative;
    display: block;
    padding: 12px 20px;
    border: 1px solid transparent;
    color: #333;
    border-width: 1px 1px 0px 0px;
    border-style: solid;
    border-color: #d2d2d2;
    font-size: 15px;
  }

  .list-group-item {
    border-left: 0px !important;
  }

  .list-group a h2 {
    font-size: medium !important;
    font-weight: normal !important;
  }

  .list-group-item.active {
    background-color: #3498db !important;
    border-color: #3498db !important;
  }

  a.navbar-brand h1 {
    font-size: 0;
  }

  .row.titulo {
    background-color: #3498db;
    color: #FFF;
    padding-top: 8px;
  }

  h1.head {
    font-size: 0;
    margin: 0;
  }









  
  
  

  
  

  About the company 7Cars - 7Cars




  

    
About the company 7Cars

    

  


  

    

      

        

          
About the company 7Cars

        

      

    


    

      

        

        

          

            

              
              The Company
            

          

          

            
The 7Cars system was introduced in August 2012. We found that the current systems were made using obsolete technologies and there was no room for expansion. 

    Thinking, we start with development and focus on constant improvement
Data security, fast processing and easy display of commands. 

    Our system was able to simplify processes while controlling information.

    We have an appointment
We will constantly improve with our customers.

Enter image description here

Computability – formal semantics of this "paradoxical" subprogram?

In the section "Routines as Parameters: An Example" by David Harel and Yishai Feldman, "Algorithms: The Spirit of Computing (3rd Edition, page 53-54), the authors describe the routines that can accept routines as parameters. For example,

subroutine P-with-parameter V
(1) call V-with-parameter VPlace the returned value in $ X $
(2) if $ X = 1 $ then return with 0; otherwise return with 1.

But what will our confused processor do when asked to execute the following first call to P:
Call P-with-parameter P

Then the authors explain why "serious semantic problems occur" as follows:

Syntactically, everything is fine; The routines are all called with the correct syntax and the right kinds of parameters. Yet, There is a paradox in this question, It is impossible for the call to return 0 because the value returned after defining the body of P is 0 when a call is made to V-with-parameter V That's really a call now P-with-parameter P) returns 1. The call can only return 0 if it returns 1, which is ridiculous! A similar argument shows that the P-with-parameter P call can not return 1, but according to P's text, it can not return anything other than 0 or 1. So, what does it matter? Does this strange call contain an endless rocking process? Is it simply forbidden by the language? None of these suggestions sounds right. With the first, we may want to see the infinity of execution, which is more explicitly reflected in the text. The second is even worse, as it is not clear how to characterize the banned programs
syntactically. Obviously, formal semantics for such a language must include precise and unambiguous answers to such questions.

I'm curious: How do programming languages ​​(especially functional programming languages ​​like Haskell) solve this "paradox"? Is it possible to write subroutines like this P-with-parameter V in (real) programming languages? If so, what is their formal semantics?

Is beta-reduction in the theory of types in category theory regarded as the basis for the Homent sensor adaptation, as a denotational or operational semantics?

Nlab's article on the relationship between type theory and category theory states that "beta reduction" in the type theory "county for hom-tensor adjunction" in category theory and "substitution" "composition of classification" corresponds to "morphisms / pullback of Display cards "accordingly.

Are these regarded as designation or operation semantics?

An operational semantics for the valuation strategy of the normal order according to lambda calculus

TAPL book, page 56 reads:

In the normal ordering strategy, the redex is the left and the far out
always reduced first.

I understand this as limiting the full beta reduction evaluation strategy, the reduction rules of which are given as follows:

$$ frac {t_1 to t_1 & # 39;} {t_1 t_2 to t_1 & # 39; t_2} $$

$$ frac {t_2 to t_2 } {t_1 t_2 to t_1 t_2 $$

$$ frac {t_1 to t_1 & # 39;} {λx. t_1 to λx. t_1 & # 39 ;; $$

$$ frac {(λx.t_1) t_2} {(x to t_2) t_1} $$

My question is how to transform these rules so that the normal order strategy condition is met.

Programming Languages ​​- What relationship and differences exist between reification and cross-semantic semantics?

https://en.wikipedia.org/wiki/Type_erasure says

Delete type refers to the load time process, which removes explicit type annotations from a program before it runs at run time. Operational semantics that do not require any type-aware programs are called Semantics of type cancellationto contrast Type transfer semantics, The ability to specify a type-delete semantics is a kind of abstraction principle that ensures that the run-time execution of a program does not depend on type information. In the context of generic programming, the opposite is called the type cancellation reification,

  • Opposed the semantics of reification and type transfer of type cancellation?
  • In which relation and between which differences is the semantics of reification and type transfer? Do they mean the same thing?

The best I can find out about them are the following two books. I'm not sure about my question yet.

About type-deletion against type-transfer, Types and programming languages from Pierce says:

23.7 Deletion and Evaluation Sequence

The operating semantics assigned to the system F in Figure 23-1 is a Type handover
semantics: When a polymorphic function encounters a type argument, the type is
actually used in the body of the function. The ML implementation of
System F in Chapter 25 does just that.
In a more realistic interpreter or compiler for a programming language
Based on system F, this type of manipulation could be a runtime type
considerable costs. In addition, it is easy to see that type comments at runtime do not play a significant role as no run time decisions are made
The Basis of Types: We can take a well-typed program, rewrite its type annotations arbitrarily, and get a program that behaves the same way.

For these reasons, many polymorphic languages ​​use a instead Type erasure
semantics, where all types are deleted after the type check phase and
The resulting untyped terms are interpreted or compiled into machine code.

About the kind of cancellation vs reification, Programming language pragmatics from Scott says:

C # 2.0 could implement an implementation based on reference rather than
Clear, Rei fi cation creates a different concrete type each time a generic is instantiated with different arguments. Some types are visible in the reflection library (csNames.GetType().ToString() returns "Arbiter 1 (System.Double)"
and it is perfectly acceptable to call new T() if T is a type parameter with a null argument constructor (a limitation is required for this effect). Besides, where
The Java compiler must generate implicit type transformations to meet the requirements of
to ensure the virtual machine (which knows nothing about generic drugs) and type-safe
Interaction with old code (which can pass a parameter or return a result of)
(an inappropriate type), the C # compiler can be assured that such checks will never be performed
be needed and can therefore be omitted. The result is faster code.

Thank you very much.